kiln-ai 0.11.1__py3-none-any.whl → 0.13.0__py3-none-any.whl

{kiln_ai-0.11.1.dist-info → kiln_ai-0.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiln-ai
-Version: 0.11.1
+Version: 0.13.0
 Summary: Kiln AI
 Project-URL: Homepage, https://getkiln.ai
 Project-URL: Repository, https://github.com/Kiln-AI/kiln
@@ -13,20 +13,20 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
+Requires-Dist: boto3>=1.37.10
 Requires-Dist: coverage>=7.6.4
+Requires-Dist: google-cloud-aiplatform>=1.84.0
 Requires-Dist: jsonschema>=4.23.0
-Requires-Dist: langchain-aws>=0.2.4
-Requires-Dist: langchain-fireworks>=0.2.5
-Requires-Dist: langchain-groq>=0.2.0
-Requires-Dist: langchain-ollama>=0.2.2
-Requires-Dist: langchain>=0.3.5
+Requires-Dist: litellm>=1.63.5
 Requires-Dist: openai>=1.53.0
 Requires-Dist: pdoc>=15.0.0
 Requires-Dist: pydantic>=2.9.2
 Requires-Dist: pytest-benchmark>=5.1.0
 Requires-Dist: pytest-cov>=6.0.0
 Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: together>=1.4.6
 Requires-Dist: typing-extensions>=4.12.2
 Description-Content-Type: text/markdown
 
@@ -71,6 +71,8 @@ The library has a [comprehensive set of docs](https://kiln-ai.github.io/Kiln/kil
   - [Load an Existing Dataset into a Kiln Task Dataset](#load-an-existing-dataset-into-a-kiln-task-dataset)
   - [Using your Kiln Dataset in a Notebook or Project](#using-your-kiln-dataset-in-a-notebook-or-project)
   - [Using Kiln Dataset in Pandas](#using-kiln-dataset-in-pandas)
+  - [Building and Running a Kiln Task from Code](#building-and-running-a-kiln-task-from-code)
+  - [Adding Custom Model or AI Provider from Code](#adding-custom-model-or-ai-provider-from-code)
 - [Full API Reference](#full-api-reference)
 
 ## Installation
@@ -232,6 +234,84 @@ final_df = pd.concat(dfs, ignore_index=True)
 print(final_df)
 ```
 
+### Building and Running a Kiln Task from Code
+
+```python
+# Step 1: Create or Load a Task -- choose one of the following 1.A or 1.B
+
+# Step 1.A: Optionally load an existing task from disk
+# task = datamodel.Task.load_from_file("path/to/task.kiln")
+
+# Step 1.B: Create a new task in code, without saving to disk.
+task = datamodel.Task(
+    name="test task",
+    instruction="Tell a joke, given a subject.",
+)
+# replace with a valid JSON schema https://json-schema.org for your task (json string, not a python dict).
+# Or delete this line to use plaintext output
+task.output_json_schema = json_joke_schema
+
+# Step 2: Create an Adapter to run the task, with a specific model and provider
+adapter = adapter_for_task(task, model_name="llama_3_1_8b", provider="groq")
+
+# Step 3: Invoke the Adapter to run the task
+task_input = "cows"
+response = await adapter.invoke(task_input)
+print(f"Output: {response.output.output}")
+
+# Step 4 (optional): Load the task from disk and print the results.
+#  This will only work if the task was loaded from disk, or you called task.save_to_file() before invoking the adapter (ephemeral tasks don't save their result to disk)
+task = datamodel.Task.load_from_file(tmp_path / "test_task.kiln")
+for run in task.runs():
+    print(f"Run: {run.id}")
+    print(f"Input: {run.input}")
+    print(f"Output: {run.output}")
+
+```
+
+### Adding Custom Model or AI Provider from Code
+
+You can add additional AI models and providers to Kiln.
+
+See our docs for more information, including how to add these from the UI:
+
+- [Custom Models From Existing Providers](https://docs.getkiln.ai/docs/models-and-ai-providers#custom-models-from-existing-providers)
+- [Custom OpenAI Compatible Servers](https://docs.getkiln.ai/docs/models-and-ai-providers#custom-openai-compatible-servers)
+
+You can also add these from code. The kiln_ai.utils.Config class helps you manage the Kiln config file (stored at `~/.kiln_settings/config.yaml`):
+
+```python
+# Addding an OpenAI compatible provider
+name = "CustomOllama"
+base_url = "http://localhost:1234/api/v1"
+api_key = "12345"
+providers = Config.shared().openai_compatible_providers or []
+existing_provider = next((p for p in providers if p["name"] == name), None)
+if existing_provider:
+    # skip since this already exists
+    return
+providers.append(
+    {
+        "name": name,
+        "base_url": base_url,
+        "api_key": api_key,
+    }
+)
+Config.shared().openai_compatible_providers = providers
+```
+
+```python
+# Add a custom model ID to an existing provider.
+new_model = "openai::gpt-3.5-turbo"
+custom_model_ids = Config.shared().custom_models
+existing_model = next((m for m in custom_model_ids if m == new_model), None)
+if existing_model:
+    # skip since this already exists
+    return
+custom_model_ids.append(new_model)
+Config.shared().custom_models = custom_model_ids
+```
+
 ## Full API Reference
 
 The library can do a lot more than the examples we've shown here.

kiln_ai-0.13.0.dist-info/RECORD

@@ -0,0 +1,103 @@
+kiln_ai/__init__.py,sha256=Sc4z8LRVFMwJUoc_DPVUriSXTZ6PO9MaJ80PhRbKyB8,34
+kiln_ai/adapters/__init__.py,sha256=XjGmWagEyOEVwVIAxjN5rYNsQWIEACT5DB7MMTxdPss,1005
+kiln_ai/adapters/adapter_registry.py,sha256=rOIL8xMm_REVO92iDphj_cBwhDOZVyS5ST-nHk4_6pA,8955
+kiln_ai/adapters/ml_model_list.py,sha256=u1nFkJm_UD1IZjBBoynmWnhx_aPkuvSuHVI69Thma3w,58939
+kiln_ai/adapters/ollama_tools.py,sha256=uObtLWfqKb9RXHN-TGGw2Y1FQlEMe0u8FgszI0zQn6U,3550
+kiln_ai/adapters/prompt_builders.py,sha256=LYHTIaisQMBFtWDRIGo1QJgOsmQ-NBpQ8fI4eImHxaQ,15269
+kiln_ai/adapters/provider_tools.py,sha256=pVLziYwHQxOZODil3iyn-BnW8CyCYnFsSdjerliWqvs,14671
+kiln_ai/adapters/run_output.py,sha256=RAi2Qp6dmqJVNm3CxbNTdAuhitHfH5NiUGbf6ygUP-k,257
+kiln_ai/adapters/test_adapter_registry.py,sha256=eDLHqv9mwgdde221pa47bTV87vCXwkUyjqsas-iFUrY,6123
+kiln_ai/adapters/test_generate_docs.py,sha256=M-uKcgF3hQmlEFOJ0o7DyL-9RgitGzkfROV-Dxtooec,2770
+kiln_ai/adapters/test_ollama_tools.py,sha256=xAUzL0IVmmXadVehJu1WjqbhpKEYGAgGt3pWx7hrubc,2514
+kiln_ai/adapters/test_prompt_adaptors.py,sha256=J1ZGZ8GG7SxP3_J3Zw0e6XmZY4NyPmUGX3IPgjh2LD8,7767
+kiln_ai/adapters/test_prompt_builders.py,sha256=5Xvfr-oQg_LLrle6UqfpRHWcPUYa8ywG3aL1rM7q1Jw,22054
+kiln_ai/adapters/test_provider_tools.py,sha256=T2t99i4LnH4xilmyV4przff3MnTdDvAnTmaiYhFPShE,26621
+kiln_ai/adapters/data_gen/__init__.py,sha256=QTZWaf7kq5BorhPvexJfwDEKmjRmIbhwW9ei8LW2SIs,276
+kiln_ai/adapters/data_gen/data_gen_prompts.py,sha256=kudjHnAz7L3q0k_NLyTlaIV7M0uRFrxXNcfcnjOE2uc,5810
+kiln_ai/adapters/data_gen/data_gen_task.py,sha256=0PuYCcj09BtpgNj23mKj_L45mKZBdV5VreUeZ-Tj_xM,6642
+kiln_ai/adapters/data_gen/test_data_gen_task.py,sha256=cRKUKMvC0uVompbmPTKwbnQ_N3c0cQDm4J_9H4Y5U18,10129
+kiln_ai/adapters/eval/__init__.py,sha256=0ptbK0ZxWuraxGn_WMgmE1tcaq0k5t-g-52kVohvWCg,693
+kiln_ai/adapters/eval/base_eval.py,sha256=jVXMiVBC07ZnLEuZVAjUAYewsnuV99put39n_GZcG1M,7261
+kiln_ai/adapters/eval/eval_runner.py,sha256=h3DvRFM5J5LDJqaLzNJ-q9i5LRycv2J9Ev5nw1mUDUQ,10806
+kiln_ai/adapters/eval/g_eval.py,sha256=muJuolDz3SSJNcruqkMmgo8P3sX5Pzm6XD7vtfiVeX4,14298
+kiln_ai/adapters/eval/registry.py,sha256=gZ_s0VgEx79Fswkgi1tS4yOl7lzpkvUBJZ62RldhM_w,626
+kiln_ai/adapters/eval/test_base_eval.py,sha256=_1CiOUOiBt1R_gGYMcRblrPkHf-H4uIlvfcHj5-Wh7o,10724
+kiln_ai/adapters/eval/test_eval_runner.py,sha256=82WPE_frNRTSQ2lylqT0inkqcDgM72nWt8GEuoDkJ7w,18568
+kiln_ai/adapters/eval/test_g_eval.py,sha256=XSZ12BEqhzYLOfCg1VFZwu2DkbI9h4kVCqOFgzp9gX8,16163
+kiln_ai/adapters/eval/test_g_eval_data.py,sha256=8caiZfLWnXVX8alrBPrH7L7gqqSS9vO7u6PzcHurQcA,27769
+kiln_ai/adapters/fine_tune/__init__.py,sha256=DxdTR60chwgck1aEoVYWyfWi6Ed2ZkdJj0lar-SEAj4,257
+kiln_ai/adapters/fine_tune/base_finetune.py,sha256=MxSnBiapWfZQw5UmkYAtC0QXj2zDeF9Ows0k0g3p1IA,6455
+kiln_ai/adapters/fine_tune/dataset_formatter.py,sha256=qRhSSkMhTWn13OMb6LKPVwAU7uY4bB49GDiVSuhDkNg,14449
+kiln_ai/adapters/fine_tune/finetune_registry.py,sha256=CvcEVxtKwjgCMA-oYH9Tpjn1DVWmMzgHpXJOZ0YQA8k,610
+kiln_ai/adapters/fine_tune/fireworks_finetune.py,sha256=6IfTDn_8tg6PR0OFudRx6V7Wjvf4P7t0fm_xyRwII68,13978
+kiln_ai/adapters/fine_tune/openai_finetune.py,sha256=Dz9E_0BWfrIkvv8ArZe-RKPwbIKPZ3v8rfbc3JELyTY,8571
+kiln_ai/adapters/fine_tune/test_base_finetune.py,sha256=0zWxFYrDGVuoQNQmi9vVUEkBc4mstfHnsUjQmiJA-sE,10864
+kiln_ai/adapters/fine_tune/test_dataset_formatter.py,sha256=T3jbFZooLVBaGCE0LUVxwPxzM3l8IY41zUj3jPk-Zi8,24027
+kiln_ai/adapters/fine_tune/test_fireworks_tinetune.py,sha256=e88z5-KtU9Y7frXqCVy6r6iE6S-tInn5oMOqmSnbR2I,18144
+kiln_ai/adapters/fine_tune/test_openai_finetune.py,sha256=H63Xk2PNHbt5Ev5IQpdR9JZ4uz-Huo2gfuC4mHHqe0w,20011
+kiln_ai/adapters/fine_tune/test_together_finetune.py,sha256=YHtOHi2bsZcUDVHY62DTRKF3ZQry3Dv-qeW8povyR1o,17991
+kiln_ai/adapters/fine_tune/together_finetune.py,sha256=kp-60ClwUimtjhRDsvPErS5whLDsBHGZhw8ITQ9JWCM,13868
+kiln_ai/adapters/model_adapters/__init__.py,sha256=m5GRtOHwVVvp_XDOss8c1X3NFf1wQQlC2eBgI4tXQhM,212
+kiln_ai/adapters/model_adapters/base_adapter.py,sha256=ifPJMg0nEKamfOSmBIsnp_MRFfBs47FLeQrLbav34yA,9872
+kiln_ai/adapters/model_adapters/litellm_adapter.py,sha256=c4J_tIpM96KWS2qzoPaQmBj7X7mHyRMShdkmEh7_EHM,16129
+kiln_ai/adapters/model_adapters/litellm_config.py,sha256=7-tIh5cuVu23Uy2Sd6q7UCT_4VgevBsAzVhQMj6Svgw,425
+kiln_ai/adapters/model_adapters/test_base_adapter.py,sha256=uQyKrHLN3Jha6R-6SWkEME6brQecVFdPTSXogo-xpt0,6556
+kiln_ai/adapters/model_adapters/test_litellm_adapter.py,sha256=QpnzuReNeBzvvRYnNj_5c8l1PS7NyrDDUQx_o21IIH4,13731
+kiln_ai/adapters/model_adapters/test_saving_adapter_results.py,sha256=1XFQQxdSIbqSoQEdxHOYJcY0cMb59qpTDPOmL9bW4B8,7870
+kiln_ai/adapters/model_adapters/test_structured_output.py,sha256=lHZSuPyvr--WCCEIik5OFqfvufmooPBbbUlSMUVvqmE,12516
+kiln_ai/adapters/parsers/__init__.py,sha256=TGJS_8JhjUwg5Bnq4cDmwt5eIRo4vowmcL2A72L1Hzk,202
+kiln_ai/adapters/parsers/base_parser.py,sha256=DaoZVEOOuFTMZd5ZTpl_as6-xc9NPWGP2fAmP12J58M,389
+kiln_ai/adapters/parsers/json_parser.py,sha256=IszrBrhIFrrVr76UZsuejkBdqpZG27mU72264HVgVzE,1274
+kiln_ai/adapters/parsers/parser_registry.py,sha256=G9bAZrnWrR0a82JAQHsSqA2o7-CjrZUBANZljY_6ZxE,623
+kiln_ai/adapters/parsers/r1_parser.py,sha256=XHc_dKxiQjj8wG1w__rTmJVqa4fIg5L1g-igbv5Rl_g,2965
+kiln_ai/adapters/parsers/test_json_parser.py,sha256=9kdWe_vRC5wjP8A1Ym6Zu6enDIz4ARCNiRpcZr7_3ak,1971
+kiln_ai/adapters/parsers/test_parser_registry.py,sha256=S4MdX7cnhCbmeKq8tZwMwRdGWr-019Z-fw5zey9Wm08,1043
+kiln_ai/adapters/parsers/test_r1_parser.py,sha256=VvCT_qCAfIbutFsxnpEzyZg-m5XLg7hI-Sorh2PplYw,4898
+kiln_ai/adapters/repair/__init__.py,sha256=dOO9MEpEhjiwzDVFg3MNfA2bKMPlax9iekDatpTkX8E,217
+kiln_ai/adapters/repair/repair_task.py,sha256=iW0bHWQq6Tir6ULTATWFS0zpwNji8Tbwhm2lZu52RsM,3342
+kiln_ai/adapters/repair/test_repair_task.py,sha256=2jO0_aDPzbmZHC0skZBcKp3t9K4gISko3iSGCFHhQRs,7945
+kiln_ai/datamodel/__init__.py,sha256=GbRfDrdSq9d_-HxzmFIicTmLO3qz-O3XGvSwDPh3XCk,1957
+kiln_ai/datamodel/basemodel.py,sha256=Qsr3Kxq5B5rfPZxQFrfOMTGwInnfYy5srd8nK0nwOs0,22204
+kiln_ai/datamodel/datamodel_enums.py,sha256=HUnGI_ZGQqyOicqEFFutZRWSANlQRQwfBu3XhVQFQSc,2270
+kiln_ai/datamodel/dataset_filters.py,sha256=hWKxGJ-mSl4y0igyNcpmRoRYCiGrf0_uN4MMU9Fe_ng,3180
+kiln_ai/datamodel/dataset_split.py,sha256=q4l4SlUvjLV547bzk7Z-fbmj_o26GDcYOZ2rA5RPh3c,5612
+kiln_ai/datamodel/eval.py,sha256=kio2LqQ87MsP75DJTiIVdVfopTZXH4xjGN9g11V1mUU,13826
+kiln_ai/datamodel/finetune.py,sha256=TYoNVRAfbjqvrY-1YmHwG6xSoDljiJWuuVcTbvQAJL4,4569
+kiln_ai/datamodel/json_schema.py,sha256=qIlR8btXhN-8Yj5GhwebzPLUHPw2sJC3uM1axV2xV7w,3032
+kiln_ai/datamodel/model_cache.py,sha256=9X4aAigbkFdytckgw8InCMh86uBna0ME_1HJSeMPEn0,4495
+kiln_ai/datamodel/project.py,sha256=uVH2_3TDFtsG_tpts81A-zbd9uPDFxAwMCKZt_km3IE,727
+kiln_ai/datamodel/prompt.py,sha256=70JPYHfgyX18cHW_DXoMzIOA28Jbaz6gyabElmpycyc,1161
+kiln_ai/datamodel/prompt_id.py,sha256=eU2TV0RZapn-BgnZ4sOSNOOVEQ3aPaLzW4YSYCd3OBo,2531
+kiln_ai/datamodel/registry.py,sha256=XwGFXJFKZtOpR1Z9ven6SftggfADdZRm8TFxCEVtfUQ,957
+kiln_ai/datamodel/strict_mode.py,sha256=sm4Xka8mnJHCShtbh6MMU5dDQv-cLj8lHgHkmFKpsl0,849
+kiln_ai/datamodel/task.py,sha256=r-_zgrQCIiIkN8gvBISdU449Z9oKp7E1XL0lkik_rVI,7036
+kiln_ai/datamodel/task_output.py,sha256=uIYR8EyWv8Bbl60gPRuTIUSvfGGzP9Ltc5P280HyTpY,12931
+kiln_ai/datamodel/task_run.py,sha256=yquE0jyr_9WzcvrMsEmZfXUnn8zZDEZIXZhVcVBMrT8,7038
+kiln_ai/datamodel/test_basemodel.py,sha256=sJ8wXGef2WxzbrbMTYgrOwmkd5J6sHkly-cQBO2IZh4,18126
+kiln_ai/datamodel/test_dataset_filters.py,sha256=v88QPkIsq4diUmoUF3-qj5KAW2rLRp0KDAm_pexbFy4,1894
+kiln_ai/datamodel/test_dataset_split.py,sha256=5CHO1Lq4xQBB72tV2SPER7OZODJNvj15qxi_cYBV2Rs,11157
+kiln_ai/datamodel/test_datasource.py,sha256=H4Kc-Im9eM7WnADWZXdoiOIrOl05RtkyuhTCKiRimyU,3905
+kiln_ai/datamodel/test_eval_model.py,sha256=J7MqwWBgPpeXGqh3IacVUUHdZFJSZ2MgTsUNu-hNOJw,19528
+kiln_ai/datamodel/test_example_models.py,sha256=fpqh0u7zFhWHcRHgtxCjX8RD2oKHYOP_mJJymaUhEZU,20944
+kiln_ai/datamodel/test_json_schema.py,sha256=UgKwAFcdrJTq2byh7Yf-HoSAtiHiGAsNZxfkIvoMxIg,3915
+kiln_ai/datamodel/test_model_cache.py,sha256=Fy-ucYNzS5JEG-8SFY4nVHA8iRbXXxai20f8_oGl97o,8184
+kiln_ai/datamodel/test_model_perf.py,sha256=NdD7L8XraGkunaEKGPsfYwdcbIgdjhFanOO3G6hU158,3235
+kiln_ai/datamodel/test_models.py,sha256=hmV7sTbOamWJCwOY96w-g4PQRv4Uai-XaHtg0QKH-ak,19295
+kiln_ai/datamodel/test_nested_save.py,sha256=xciCddqvPyKyoyjC5Lx_3Kh1t4LJv1xYRAPazR3SRcs,5588
+kiln_ai/datamodel/test_output_rating.py,sha256=zvPIp2shAgCs2RQBgwYoL09fRA3krHvgAqUa91RlWR0,15125
+kiln_ai/datamodel/test_prompt_id.py,sha256=ihyXVPQi0dSLGnBM7rTXRnVaiWXhh7HJmSy4nZZKmso,4225
+kiln_ai/datamodel/test_registry.py,sha256=PhS4anLi5Bf_023obuTlO5DALhtPB8WIc_bX12Yg6Po,2705
+kiln_ai/datamodel/test_task.py,sha256=FYyoEqJXQIy8rcBsLTdki4-1z9COnZQk1-aoS3ZoNuU,5307
+kiln_ai/utils/__init__.py,sha256=PTD0MwBCKAMIOGsTAwsFaJOusTJJoRFTfOGqRvCaU-E,142
+kiln_ai/utils/config.py,sha256=IKPk9dMecDbqoBkfj52GT9xeity_y_sGP-vdm9CcKe4,8201
+kiln_ai/utils/dataset_import.py,sha256=HvTCdK9OO8WE3Runn8_Vsks5KpCTckGIzAA7JKe-cWI,6956
+kiln_ai/utils/exhaustive_error.py,sha256=TkkRixIAR3CPEKHeAJzyv0mtxp6BxUBKMvobA3vzQug,262
+kiln_ai/utils/formatting.py,sha256=VtB9oag0lOGv17dwT7OPX_3HzBfaU9GsLH-iLete0yM,97
+kiln_ai/utils/name_generator.py,sha256=v26TgpCwQbhQFcZvzgjZvURinjrOyyFhxpsI6NQrHKc,1914
+kiln_ai/utils/test_config.py,sha256=Jw3nMFeIgZUsZDRJJY2HpB-2EkR2NoZ-rDe_o9oA7ws,9174
+kiln_ai/utils/test_dataset_import.py,sha256=ZZOt7zqtaEIlMMx0VNXyRegDvnVqbWY2bcz-iMY_Oag,17427
+kiln_ai/utils/test_name_geneator.py,sha256=9-hSTBshyakqlPbFnNcggwLrL7lcPTitauBYHg9jFWI,1513
+kiln_ai-0.13.0.dist-info/METADATA,sha256=csSjOcBVu_PrMLFU16V54GmCmibcfCoeCWV0fWydbEA,12238
+kiln_ai-0.13.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kiln_ai-0.13.0.dist-info/licenses/LICENSE.txt,sha256=_NA5pnTYgRRr4qH6lE3X-TuZJ8iRcMUi5ASoGr-lEx8,1209
+kiln_ai-0.13.0.dist-info/RECORD,,

kiln_ai/adapters/model_adapters/langchain_adapters.py

@@ -1,302 +0,0 @@
-import os
-from typing import Any, Dict
-
-from langchain_aws import ChatBedrockConverse
-from langchain_core.language_models import LanguageModelInput
-from langchain_core.language_models.chat_models import BaseChatModel
-from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
-from langchain_core.messages.base import BaseMessage
-from langchain_core.runnables import Runnable
-from langchain_fireworks import ChatFireworks
-from langchain_groq import ChatGroq
-from langchain_ollama import ChatOllama
-from pydantic import BaseModel
-
-import kiln_ai.datamodel as datamodel
-from kiln_ai.adapters.ml_model_list import (
-    KilnModelProvider,
-    ModelProviderName,
-    StructuredOutputMode,
-)
-from kiln_ai.adapters.model_adapters.base_adapter import (
-    COT_FINAL_ANSWER_PROMPT,
-    AdapterInfo,
-    BaseAdapter,
-    BasePromptBuilder,
-    RunOutput,
-)
-from kiln_ai.adapters.ollama_tools import (
-    get_ollama_connection,
-    ollama_base_url,
-    ollama_model_installed,
-)
-from kiln_ai.utils.config import Config
-from kiln_ai.utils.exhaustive_error import raise_exhaustive_enum_error
-
-LangChainModelType = BaseChatModel | Runnable[LanguageModelInput, Dict | BaseModel]
-
-
-class LangchainAdapter(BaseAdapter):
-    _model: LangChainModelType | None = None
-
-    def __init__(
-        self,
-        kiln_task: datamodel.Task,
-        custom_model: BaseChatModel | None = None,
-        model_name: str | None = None,
-        provider: str | None = None,
-        prompt_builder: BasePromptBuilder | None = None,
-        tags: list[str] | None = None,
-    ):
-        if custom_model is not None:
-            self._model = custom_model
-
-            # Attempt to infer model provider and name from custom model
-            if provider is None:
-                provider = "custom.langchain:" + custom_model.__class__.__name__
-
-            if model_name is None:
-                model_name = "custom.langchain:unknown_model"
-                if hasattr(custom_model, "model_name") and isinstance(
-                    getattr(custom_model, "model_name"), str
-                ):
-                    model_name = "custom.langchain:" + getattr(
-                        custom_model, "model_name"
-                    )
-                if hasattr(custom_model, "model") and isinstance(
-                    getattr(custom_model, "model"), str
-                ):
-                    model_name = "custom.langchain:" + getattr(custom_model, "model")
-        elif model_name is not None:
-            # default provider name if not provided
-            provider = provider or "custom.langchain.default_provider"
-        else:
-            raise ValueError(
-                "model_name and provider must be provided if custom_model is not provided"
-            )
-
-        if model_name is None:
-            raise ValueError("model_name must be provided")
-
-        super().__init__(
-            kiln_task,
-            model_name=model_name,
-            model_provider_name=provider,
-            prompt_builder=prompt_builder,
-            tags=tags,
-        )
-
-    async def model(self) -> LangChainModelType:
-        # cached model
-        if self._model:
-            return self._model
-
-        self._model = await self.langchain_model_from()
-
-        # Decide if we want to use Langchain's structured output:
-        # 1. Only for structured tasks
-        # 2. Only if the provider's mode isn't json_instructions (only mode that doesn't use an API option for structured output capabilities)
-        provider = self.model_provider()
-        use_lc_structured_output = (
-            self.has_structured_output()
-            and provider.structured_output_mode
-            != StructuredOutputMode.json_instructions
-        )
-
-        if use_lc_structured_output:
-            if not hasattr(self._model, "with_structured_output") or not callable(
-                getattr(self._model, "with_structured_output")
-            ):
-                raise ValueError(
-                    f"model {self._model} does not support structured output, cannot use output_json_schema"
-                )
-            # Langchain expects title/description to be at top level, on top of json schema
-            output_schema = self.kiln_task.output_schema()
-            if output_schema is None:
-                raise ValueError(
-                    f"output_json_schema is not valid json: {self.kiln_task.output_json_schema}"
-                )
-            output_schema["title"] = "task_response"
-            output_schema["description"] = "A response from the task"
-            with_structured_output_options = self.get_structured_output_options(
-                self.model_name, self.model_provider_name
-            )
-            self._model = self._model.with_structured_output(
-                output_schema,
-                include_raw=True,
-                **with_structured_output_options,
-            )
-        return self._model
-
-    async def _run(self, input: Dict | str) -> RunOutput:
-        provider = self.model_provider()
-        model = await self.model()
-        chain = model
-        intermediate_outputs = {}
-
-        prompt = self.build_prompt()
-        user_msg = self.prompt_builder.build_user_message(input)
-        messages = [
-            SystemMessage(content=prompt),
-            HumanMessage(content=user_msg),
-        ]
-
-        run_strategy, cot_prompt = self.run_strategy()
-
-        if run_strategy == "cot_as_message":
-            if not cot_prompt:
-                raise ValueError("cot_prompt is required for cot_as_message strategy")
-            messages.append(SystemMessage(content=cot_prompt))
-        elif run_strategy == "cot_two_call":
-            if not cot_prompt:
-                raise ValueError("cot_prompt is required for cot_two_call strategy")
-            messages.append(
-                SystemMessage(content=cot_prompt),
-            )
-
-            # Base model (without structured output) used for COT message
-            base_model = await self.langchain_model_from()
-
-            cot_messages = [*messages]
-            cot_response = await base_model.ainvoke(cot_messages)
-            intermediate_outputs["chain_of_thought"] = cot_response.content
-            messages.append(AIMessage(content=cot_response.content))
-            messages.append(HumanMessage(content=COT_FINAL_ANSWER_PROMPT))
-
-        response = await chain.ainvoke(messages)
-
-        # Langchain may have already parsed the response into structured output, so use that if available.
-        # However, a plain string may still be fixed at the parsing layer, so not being structured isn't a critical failure (yet)
-        if (
-            self.has_structured_output()
-            and isinstance(response, dict)
-            and "parsed" in response
-            and isinstance(response["parsed"], dict)
-        ):
-            structured_response = response["parsed"]
-            return RunOutput(
-                output=self._munge_response(structured_response),
-                intermediate_outputs=intermediate_outputs,
-            )
-
-        if not isinstance(response, BaseMessage):
-            raise RuntimeError(f"response is not a BaseMessage: {response}")
-
-        text_content = response.content
-        if not isinstance(text_content, str):
-            raise RuntimeError(f"response is not a string: {text_content}")
-
-        return RunOutput(
-            output=text_content,
-            intermediate_outputs=intermediate_outputs,
-        )
-
-    def adapter_info(self) -> AdapterInfo:
-        return AdapterInfo(
-            model_name=self.model_name,
-            model_provider=self.model_provider_name,
-            adapter_name="kiln_langchain_adapter",
-            prompt_builder_name=self.prompt_builder.__class__.prompt_builder_name(),
-            prompt_id=self.prompt_builder.prompt_id(),
-        )
-
-    def _munge_response(self, response: Dict) -> Dict:
-        # Mistral Large tool calling format is a bit different. Convert to standard format.
-        if (
-            "name" in response
-            and response["name"] == "task_response"
-            and "arguments" in response
-        ):
-            return response["arguments"]
-        return response
-
-    def get_structured_output_options(
-        self, model_name: str, model_provider_name: str
-    ) -> Dict[str, Any]:
-        provider = self.model_provider()
-        if not provider:
-            return {}
-
-        options = {}
-        # We may need to add some provider specific logic here if providers use different names for the same mode, but everyone is copying openai for now
-        match provider.structured_output_mode:
-            case StructuredOutputMode.function_calling:
-                options["method"] = "function_calling"
-            case StructuredOutputMode.json_mode:
-                options["method"] = "json_mode"
-            case StructuredOutputMode.json_instruction_and_object:
-                # We also pass instructions
-                options["method"] = "json_mode"
-            case StructuredOutputMode.json_schema:
-                options["method"] = "json_schema"
-            case StructuredOutputMode.json_instructions:
-                # JSON done via instructions in prompt, not via API
-                pass
-            case StructuredOutputMode.default:
-                if provider.name == ModelProviderName.ollama:
-                    # Ollama has great json_schema support, so use that: https://ollama.com/blog/structured-outputs
-                    options["method"] = "json_schema"
-                else:
-                    # Let langchain decide the default
-                    pass
-            case _:
-                raise_exhaustive_enum_error(provider.structured_output_mode)
-
-        return options
-
-    async def langchain_model_from(self) -> BaseChatModel:
-        provider = self.model_provider()
-        return await langchain_model_from_provider(provider, self.model_name)
-
-
-async def langchain_model_from_provider(
-    provider: KilnModelProvider, model_name: str
-) -> BaseChatModel:
-    if provider.name == ModelProviderName.openai:
-        # We use the OpenAICompatibleAdapter for OpenAI
-        raise ValueError("OpenAI is not supported in Langchain adapter")
-    elif provider.name == ModelProviderName.openai_compatible:
-        # We use the OpenAICompatibleAdapter for OpenAI compatible
-        raise ValueError("OpenAI compatible is not supported in Langchain adapter")
-    elif provider.name == ModelProviderName.groq:
-        api_key = Config.shared().groq_api_key
-        if api_key is None:
-            raise ValueError(
-                "Attempted to use Groq without an API key set. "
-                "Get your API key from https://console.groq.com/keys"
-            )
-        return ChatGroq(**provider.provider_options, groq_api_key=api_key)  # type: ignore[arg-type]
-    elif provider.name == ModelProviderName.amazon_bedrock:
-        api_key = Config.shared().bedrock_access_key
-        secret_key = Config.shared().bedrock_secret_key
-        # langchain doesn't allow passing these, so ugly hack to set env vars
-        os.environ["AWS_ACCESS_KEY_ID"] = api_key
-        os.environ["AWS_SECRET_ACCESS_KEY"] = secret_key
-        return ChatBedrockConverse(
-            **provider.provider_options,
-        )
-    elif provider.name == ModelProviderName.fireworks_ai:
-        api_key = Config.shared().fireworks_api_key
-        return ChatFireworks(**provider.provider_options, api_key=api_key)
-    elif provider.name == ModelProviderName.ollama:
-        # Ollama model naming is pretty flexible. We try a few versions of the model name
-        potential_model_names = []
-        if "model" in provider.provider_options:
-            potential_model_names.append(provider.provider_options["model"])
-        if "model_aliases" in provider.provider_options:
-            potential_model_names.extend(provider.provider_options["model_aliases"])
-
-        # Get the list of models Ollama supports
-        ollama_connection = await get_ollama_connection()
-        if ollama_connection is None:
-            raise ValueError("Failed to connect to Ollama. Ensure Ollama is running.")
-
-        for model_name in potential_model_names:
-            if ollama_model_installed(ollama_connection, model_name):
-                return ChatOllama(model=model_name, base_url=ollama_base_url())
-
-        raise ValueError(f"Model {model_name} not installed on Ollama")
-    elif provider.name == ModelProviderName.openrouter:
-        raise ValueError("OpenRouter is not supported in Langchain adapter")
-    else:
-        raise ValueError(f"Invalid model or provider: {model_name} - {provider.name}")

kiln_ai/adapters/model_adapters/openai_compatible_config.py

@@ -1,11 +0,0 @@
-from dataclasses import dataclass
-
-
-@dataclass
-class OpenAICompatibleConfig:
-    api_key: str
-    model_name: str
-    provider_name: str
-    base_url: str | None = None  # Defaults to OpenAI
-    default_headers: dict[str, str] | None = None
-    openrouter_style_reasoning: bool = False