kiln-server 0.0.1__tar.gz

kiln_server-0.0.1/LICENSE.txt

@@ -0,0 +1,4 @@
+
+All rights reserved.
+
+Copyright (c) Steve Cosman, Chesterfield Laboratories Inc.

kiln_server-0.0.1/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.1
+Name: kiln-server
+Version: 0.0.1
+Summary: Kiln AI Server
+Home-page: https://kiln-ai.com
+License: Proprietary
+Author: Steve Cosman, Chesterfield Laboratories Inc
+Author-email: scosman@users.noreply.github.com
+Requires-Python: >=3.9
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: kiln-ai
+Project-URL: Bug Tracker, https://github.com/Kiln-AI/kiln/issues
+Project-URL: Documentation, https://github.com/Kiln-AI/kiln#readme
+Project-URL: Repository, https://github.com/Kiln-AI/kiln
+Description-Content-Type: text/markdown
+
+# Kiln AI Server
+
+[![PyPI - Version](https://img.shields.io/pypi/v/kiln-server.svg)](https://pypi.org/project/kiln-server)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/kiln-server.svg)](https://pypi.org/project/kiln-server)
+
+---
+
+## About
+
+The Kiln AI Server is a Python library that provides a REST API server for the Kiln AI datamodel.
+
+See our [website](https://kiln-ai.com) for more information.
+
+## Table of Contents
+
+- [Installation](#installation)
+
+## Installation
+
+```console
+pip install kiln_server
+```
+

kiln_server-0.0.1/README.md

@@ -0,0 +1,22 @@
+# Kiln AI Server
+
+[![PyPI - Version](https://img.shields.io/pypi/v/kiln-server.svg)](https://pypi.org/project/kiln-server)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/kiln-server.svg)](https://pypi.org/project/kiln-server)
+
+---
+
+## About
+
+The Kiln AI Server is a Python library that provides a REST API server for the Kiln AI datamodel.
+
+See our [website](https://kiln-ai.com) for more information.
+
+## Table of Contents
+
+- [Installation](#installation)
+
+## Installation
+
+```console
+pip install kiln_server
+```

kiln_server-0.0.1/kiln_server/custom_errors.py

@@ -0,0 +1,70 @@
+from fastapi import FastAPI, HTTPException, Request, status
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
+from pydantic import ValidationError
+
+
+def format_error_loc(loc: tuple):
+    if not loc:
+        return ""
+    formatted = []
+    # Skip the first item if it's "body" (case-insensitive)
+    start_index = 1 if loc and loc[0].lower() == "body" else 0
+    for i, item in enumerate(loc[start_index:]):
+        if item is not None and item != "":
+            if isinstance(item, str):
+                formatted.append(
+                    item.capitalize() if i == 0 else "." + item.capitalize()
+                )
+            elif isinstance(item, int):
+                formatted.append(f"[{item}]")
+            else:
+                formatted.append(str(item))
+    return "".join(formatted)
+
+
+def connect_custom_errors(app: FastAPI):
+    @app.exception_handler(ValidationError)
+    @app.exception_handler(RequestValidationError)
+    async def validation_exception_handler(
+        request: Request, exc: RequestValidationError | ValidationError
+    ):
+        # Write user friendly error messages
+        error_messages = []
+        for error in exc.errors():
+            message = error.get("msg", "Unknown error")
+            loc = error.get("loc")
+
+            # Custom helpers for common errors
+            if "String should match pattern '^[A-Za-z0-9 _-]+$'" == message:
+                message = "must consist of only letters, numbers, spaces, hyphens, and underscores"
+
+            error_messages.append(f"{format_error_loc(loc)}: {message}")
+
+        def serialize_error(error):
+            return {
+                "type": error.get("type"),
+                "loc": [str(loc) for loc in error.get("loc", [])],
+                "msg": error.get("msg"),
+                "input": str(error.get("input")),
+                "ctx": {str(k): str(v) for k, v in error.get("ctx", {}).items()},
+            }
+
+        serialized_errors = [serialize_error(error) for error in exc.errors()]
+
+        return JSONResponse(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            content={
+                "error_messages": error_messages,
+                "message": ".\n".join(error_messages),
+                "source_errors": serialized_errors,
+            },
+        )
+
+    # Wrap in a format that the client can understand (message, and error_messages)
+    @app.exception_handler(HTTPException)
+    async def http_exception_handler(request: Request, exc: HTTPException):
+        return JSONResponse(
+            status_code=exc.status_code,
+            content={"message": exc.detail},
+        )

kiln_server-0.0.1/kiln_server/project_api.py

@@ -0,0 +1,122 @@
+import os
+from pathlib import Path
+from typing import Any, Dict
+
+from fastapi import FastAPI, HTTPException
+from kiln_ai.datamodel import Project
+from kiln_ai.utils.config import Config
+
+
+def default_project_path():
+    return os.path.join(Path.home(), "Kiln Projects")
+
+
+def project_from_id(project_id: str) -> Project:
+    project_paths = Config.shared().projects
+    if project_paths is not None:
+        for project_path in project_paths:
+            try:
+                project = Project.load_from_file(project_path)
+                if project.id == project_id:
+                    return project
+            except Exception as e:
+                print(f"Error loading project, skipping: {project_path}: {e}")
+
+    raise HTTPException(
+        status_code=404,
+        detail=f"Project not found. ID: {project_id}",
+    )
+
+
+def add_project_to_config(project_path: str):
+    projects = Config.shared().projects
+    if not isinstance(projects, list):
+        projects = []
+    if project_path not in projects:
+        projects.append(project_path)
+        Config.shared().save_setting("projects", projects)
+
+
+def connect_project_api(app: FastAPI):
+    @app.post("/api/project")
+    async def create_project(project: Project) -> Project:
+        project_path = os.path.join(default_project_path(), project.name)
+        if os.path.exists(project_path):
+            raise HTTPException(
+                status_code=400,
+                detail="Project with this folder name already exists. Please choose a different name or rename the prior project's folder.",
+            )
+
+        os.makedirs(project_path)
+        project_file = os.path.join(project_path, "project.kiln")
+        project.path = Path(project_file)
+        project.save_to_file()
+
+        # add to projects list
+        add_project_to_config(project_file)
+
+        # Add path, which is usually excluded
+        return project
+
+    @app.patch("/api/project/{project_id}")
+    async def update_project(
+        project_id: str, project_updates: Dict[str, Any]
+    ) -> Project:
+        original_project = project_from_id(project_id)
+        updated_project = original_project.model_copy(update=project_updates)
+        # Force validation using model_validate()
+        Project.model_validate(updated_project.model_dump())
+        updated_project.save_to_file()
+        return updated_project
+
+    @app.get("/api/projects")
+    async def get_projects() -> list[Project]:
+        project_paths = Config.shared().projects
+        projects = []
+        for project_path in project_paths if project_paths is not None else []:
+            try:
+                project = Project.load_from_file(project_path)
+                json_project = project.model_dump()
+                json_project["path"] = project_path
+                projects.append(json_project)
+            except Exception as e:
+                print(f"Error loading project, skipping: {project_path}: {e}")
+
+        return projects
+
+    @app.get("/api/projects/{project_id}")
+    async def get_project(project_id: str) -> Project:
+        return project_from_id(project_id)
+
+    # Removes the project, but does not delete the files from disk
+    @app.delete("/api/projects/{project_id}")
+    async def delete_project(project_id: str) -> dict:
+        project = project_from_id(project_id)
+
+        # Remove from config
+        projects_before = Config.shared().projects
+        projects_after = [p for p in projects_before if p != str(project.path)]
+        Config.shared().save_setting("projects", projects_after)
+
+        return {"message": f"Project removed. ID: {project_id}"}
+
+    @app.post("/api/import_project")
+    async def import_project(project_path: str) -> Project:
+        if project_path is None or not os.path.exists(project_path):
+            raise HTTPException(
+                status_code=400,
+                detail="Project not found. Check the path and try again.",
+            )
+
+        try:
+            project = Project.load_from_file(Path(project_path))
+        except Exception as e:
+            raise HTTPException(
+                status_code=500,
+                detail=f"Failed to load project. The file be invalid: {e}",
+            )
+
+        # add to projects list
+        add_project_to_config(project_path)
+
+        return project

kiln_server-0.0.1/kiln_server/prompt_api.py

@@ -0,0 +1,36 @@
+from typing import Any, Dict, List
+
+from fastapi import FastAPI, HTTPException
+from kiln_ai.datamodel import Task
+from pydantic import BaseModel
+
+from libs.core.kiln_ai.adapters.prompt_builders import prompt_builder_from_ui_name
+from libs.server.kiln_server.project_api import project_from_id
+from libs.server.kiln_server.task_api import task_from_id
+
+
+class PromptApiResponse(BaseModel):
+    prompt: str
+    prompt_builder_name: str
+    ui_generator_name: str
+
+
+def connect_prompt_api(app: FastAPI):
+    @app.get("/api/projects/{project_id}/task/{task_id}/gen_prompt/{prompt_generator}")
+    async def gen_prompt(
+        project_id: str, task_id: str, prompt_generator: str
+    ) -> PromptApiResponse:
+        task = task_from_id(project_id, task_id)
+
+        try:
+            prompt_builder_class = prompt_builder_from_ui_name(prompt_generator)
+            prompt_builder = prompt_builder_class(task)
+            prompt = prompt_builder.build_prompt()
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=str(e))
+
+        return PromptApiResponse(
+            prompt=prompt,
+            prompt_builder_name=prompt_builder_class.prompt_builder_name(),
+            ui_generator_name=prompt_generator,
+        )

kiln_server-0.0.1/kiln_server/provider_api.py

@@ -0,0 +1,329 @@
+import os
+from typing import Dict, List
+
+import requests
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+from kiln_ai.adapters.ml_model_list import (
+    ModelName,
+    ModelProviderName,
+    built_in_models,
+    provider_name_from_id,
+    provider_warnings,
+)
+from kiln_ai.utils.config import Config
+from langchain_aws import ChatBedrockConverse
+from pydantic import BaseModel
+
+
+class OllamaConnection(BaseModel):
+    message: str
+    models: List[str]
+
+
+async def connect_ollama() -> OllamaConnection:
+    # Tags is a list of Ollama models. Proves Ollama is running, and models are available.
+    try:
+        tags = requests.get("http://localhost:11434/api/tags", timeout=5).json()
+    except requests.exceptions.ConnectionError:
+        raise HTTPException(
+            status_code=417,
+            detail="Failed to connect. Ensure Ollama app is running.",
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to connect to Ollama: {e}",
+        )
+
+    # Build a list of models we support for Ollama from the built-in model list
+    supported_ollama_models = [
+        provider.provider_options["model"]
+        for model in built_in_models
+        for provider in model.providers
+        if provider.name == ModelProviderName.ollama
+    ]
+
+    if "models" in tags:
+        models = tags["models"]
+        if isinstance(models, list):
+            model_names = [model["model"] for model in models]
+            available_supported_models = [
+                model
+                for model in model_names
+                if model in supported_ollama_models
+                or model in [f"{m}:latest" for m in supported_ollama_models]
+            ]
+            if available_supported_models:
+                Config.shared().ollama_base_url = "http://localhost:11434"
+                return OllamaConnection(
+                    message="Ollama connected",
+                    models=available_supported_models,
+                )
+
+    raise HTTPException(
+        status_code=417,
+        detail="Ollama is running, but no supported models are installed. Install one or more supported model, like 'ollama pull phi3.5'.",
+    )
+
+
+class ModelDetails(BaseModel):
+    id: str
+    name: str
+
+
+class AvailableModels(BaseModel):
+    provider_name: str
+    provider_id: str
+    models: List[ModelDetails]
+
+
+class ProviderModel(BaseModel):
+    id: str
+    name: str
+
+
+class ProviderModels(BaseModel):
+    models: Dict[ModelName, ProviderModel]
+
+
+def connect_provider_api(app: FastAPI):
+    @app.get("/api/providers/models")
+    async def get_providers_models() -> ProviderModels:
+        models = {}
+        for model in built_in_models:
+            models[model.name] = ProviderModel(id=model.name, name=model.friendly_name)
+        return ProviderModels(models=models)
+
+    # returns map, of provider name to list of model names
+    @app.get("/api/available_models")
+    async def get_available_models() -> List[AvailableModels]:
+        # Providers with just keys can return all their models if keys are set
+        key_providers: List[str] = []
+
+        # Try to connect to Ollama
+        try:
+            ollama_connection = await connect_ollama()
+            if len(ollama_connection.models) > 0:
+                key_providers.append(ModelProviderName.ollama)
+        except HTTPException:
+            # skip ollama if it's not available
+            pass
+
+        for provider, provider_warning in provider_warnings.items():
+            has_keys = True
+            for required_key in provider_warning.required_config_keys:
+                if Config.shared().get_value(required_key) is None:
+                    has_keys = False
+                    break
+            if has_keys:
+                key_providers.append(provider)
+        models: List[AvailableModels] = [
+            AvailableModels(
+                provider_name=provider_name_from_id(provider),
+                provider_id=provider,
+                models=[],
+            )
+            for provider in key_providers
+        ]
+
+        for model in built_in_models:
+            for provider in model.providers:
+                if provider.name in key_providers:
+                    available_models = next(
+                        (m for m in models if m.provider_id == provider.name), None
+                    )
+                    if available_models:
+                        available_models.models.append(
+                            ModelDetails(id=model.name, name=model.friendly_name)
+                        )
+
+        return models
+
+    @app.post("/api/provider/ollama/connect")
+    async def connect_ollama_api() -> OllamaConnection:
+        return await connect_ollama()
+
+    @app.post("/api/provider/connect_api_key")
+    async def connect_api_key(payload: dict):
+        provider = payload.get("provider")
+        key_data = payload.get("key_data")
+        if not isinstance(key_data, dict) or not isinstance(provider, str):
+            return JSONResponse(
+                status_code=400,
+                content={"message": "Invalid key_data or provider"},
+            )
+
+        api_key_providers = ["openai", "groq", "bedrock", "openrouter"]
+        if provider not in api_key_providers:
+            return JSONResponse(
+                status_code=400,
+                content={"message": f"Provider {provider} not supported"},
+            )
+
+        if provider == "openai" and isinstance(key_data["API Key"], str):
+            return await connect_openai(key_data["API Key"])
+        elif provider == "groq" and isinstance(key_data["API Key"], str):
+            return await connect_groq(key_data["API Key"])
+        elif provider == "openrouter" and isinstance(key_data["API Key"], str):
+            return await connect_openrouter(key_data["API Key"])
+        elif (
+            provider == "bedrock"
+            and isinstance(key_data["Access Key"], str)
+            and isinstance(key_data["Secret Key"], str)
+        ):
+            return await connect_bedrock(key_data["Access Key"], key_data["Secret Key"])
+        else:
+            return JSONResponse(
+                status_code=400,
+                content={"message": f"Provider {provider} missing API key"},
+            )
+
+
+async def connect_openrouter(key: str):
+    try:
+        headers = {
+            "Authorization": f"Bearer {key}",
+            "Content-Type": "application/json",
+        }
+        # invalid body, but we just want to see if the key is valid
+        response = requests.post(
+            "https://openrouter.ai/api/v1/chat/completions",
+            headers=headers,
+            json={},
+        )
+
+        # 401 def means invalid API key
+        if response.status_code == 401:
+            return JSONResponse(
+                status_code=401,
+                content={
+                    "message": "Failed to connect to OpenRouter. Invalid API key."
+                },
+            )
+        else:
+            # No 401 means key is valid (even it it's an error, which we expect with empty body)
+            Config.shared().open_router_api_key = key
+
+            return JSONResponse(
+                status_code=200,
+                content={"message": "Connected to OpenRouter"},
+            )
+            # Any non-200 status code is an error
+    except Exception as e:
+        # unexpected error
+        return JSONResponse(
+            status_code=400,
+            content={"message": f"Failed to connect to OpenRouter. Error: {str(e)}"},
+        )
+
+
+async def connect_openai(key: str):
+    try:
+        headers = {
+            "Authorization": f"Bearer {key}",
+            "Content-Type": "application/json",
+        }
+        response = requests.get("https://api.openai.com/v1/models", headers=headers)
+
+        # 401 def means invalid API key, so special case it
+        if response.status_code == 401:
+            return JSONResponse(
+                status_code=401,
+                content={"message": "Failed to connect to OpenAI. Invalid API key."},
+            )
+
+        # Any non-200 status code is an error
+        response.raise_for_status()
+        # If the request is successful, the function will continue
+    except Exception as e:
+        return JSONResponse(
+            status_code=400,
+            content={"message": f"Failed to connect to OpenAI. Error: {str(e)}"},
+        )
+
+    # It worked! Save the key and return success
+    Config.shared().open_ai_api_key = key
+
+    return JSONResponse(
+        status_code=200,
+        content={"message": "Connected to OpenAI"},
+    )
+
+
+async def connect_groq(key: str):
+    try:
+        headers = {
+            "Authorization": f"Bearer {key}",
+            "Content-Type": "application/json",
+        }
+        response = requests.get(
+            "https://api.groq.com/openai/v1/models", headers=headers
+        )
+
+        if "invalid_api_key" in response.text:
+            return JSONResponse(
+                status_code=401,
+                content={"message": "Failed to connect to Groq. Invalid API key."},
+            )
+
+        # Any non-200 status code is an error
+        response.raise_for_status()
+        # If the request is successful, the function will continue
+    except Exception as e:
+        return JSONResponse(
+            status_code=400,
+            content={"message": f"Failed to connect to Groq. Error: {str(e)}"},
+        )
+
+    # It worked! Save the key and return success
+    Config.shared().groq_api_key = key
+
+    return JSONResponse(
+        status_code=200,
+        content={"message": "Connected to Groq"},
+    )
+
+
+async def connect_bedrock(access_key: str, secret_key: str):
+    try:
+        # Langchain API is not good... need to use env vars. Pop these in finally block
+        os.environ["AWS_ACCESS_KEY_ID"] = access_key
+        os.environ["AWS_SECRET_ACCESS_KEY"] = secret_key
+
+        # Fake model, but will get a credential error before AWS realizes it's wrong
+        # Ensures we don't spend money on a test call
+        llm = ChatBedrockConverse(
+            model="fake_model",
+            region_name="us-west-2",
+        )
+        llm.invoke("Hello, how are you?")
+    except Exception as e:
+        # Check for specific error messages indicating invalid credentials
+        if "UnrecognizedClientException" in str(
+            e
+        ) or "InvalidSignatureException" in str(e):
+            return JSONResponse(
+                status_code=401,
+                content={
+                    "message": "Failed to connect to Bedrock. Invalid credentials."
+                },
+            )
+        else:
+            # We still expect an error (fake model), but not for invalid credentials which means success!
+            Config.shared().bedrock_access_key = access_key
+            Config.shared().bedrock_secret_key = secret_key
+            return JSONResponse(
+                status_code=200,
+                content={"message": "Connected to Bedrock"},
+            )
+
+    finally:
+        os.environ.pop("AWS_ACCESS_KEY_ID")
+        os.environ.pop("AWS_SECRET_ACCESS_KEY")
+
+    # we shouldn't get here, but if we do, something went wrong
+    return JSONResponse(
+        status_code=400,
+        content={"message": "Unknown Bedrock Error"},
+    )