kiln-ai 0.19.0__py3-none-any.whl → 0.21.0__py3-none-any.whl

kiln_ai/adapters/model_adapters/test_saving_adapter_results.py

@@ -13,7 +13,7 @@ from kiln_ai.datamodel import (
     Task,
     Usage,
 )
-from kiln_ai.datamodel.task import RunConfig
+from kiln_ai.datamodel.task import RunConfigProperties
 from kiln_ai.utils.config import Config
 
 
@@ -41,8 +41,8 @@ def test_task(tmp_path):
 @pytest.fixture
 def adapter(test_task):
     return MockAdapter(
-        run_config=RunConfig(
-            task=test_task,
+        task=test_task,
+        run_config=RunConfigProperties(
             model_name="phi_3_5",
             model_provider_name="ollama",
             prompt_id="simple_chain_of_thought_prompt_builder",
@@ -240,8 +240,8 @@ async def test_autosave_true(test_task, adapter):
 def test_properties_for_task_output_custom_values(test_task):
     """Test that _properties_for_task_output includes custom temperature, top_p, and structured_output_mode"""
     adapter = MockAdapter(
-        run_config=RunConfig(
-            task=test_task,
+        task=test_task,
+        run_config=RunConfigProperties(
             model_name="gpt-4",
             model_provider_name="openai",
             prompt_id="simple_prompt_builder",

kiln_ai/adapters/model_adapters/test_structured_output.py

@@ -1,8 +1,10 @@
 import json
 from pathlib import Path
 from typing import Dict
+from unittest.mock import Mock, patch
 
 import pytest
+from litellm.types.utils import ModelResponse
 
 import kiln_ai.datamodel as datamodel
 from kiln_ai.adapters.adapter_registry import adapter_for_task
@@ -11,7 +13,7 @@ from kiln_ai.adapters.model_adapters.base_adapter import BaseAdapter, RunOutput,
 from kiln_ai.adapters.ollama_tools import ollama_online
 from kiln_ai.adapters.test_prompt_adaptors import get_all_models_and_providers
 from kiln_ai.datamodel import PromptId
-from kiln_ai.datamodel.task import RunConfig, RunConfigProperties
+from kiln_ai.datamodel.task import RunConfigProperties
 from kiln_ai.datamodel.test_json_schema import json_joke_schema, json_triangle_schema
 
 
@@ -40,8 +42,8 @@ async def test_structured_output_ollama(tmp_path, model_name):
 class MockAdapter(BaseAdapter):
     def __init__(self, kiln_task: datamodel.Task, response: Dict | str | None):
         super().__init__(
-            run_config=RunConfig(
-                task=kiln_task,
+            task=kiln_task,
+            run_config=RunConfigProperties(
                 model_name="phi_3_5",
                 model_provider_name="ollama",
                 prompt_id="simple_chain_of_thought_prompt_builder",
@@ -259,6 +261,7 @@ async def run_structured_input_task(
     model_name: str,
     provider: str,
     prompt_id: PromptId,
+    verify_trace_cot: bool = False,
 ):
     response, a, run = await run_structured_input_task_no_validation(
         task, model_name, provider, prompt_id
@@ -282,6 +285,32 @@ async def run_structured_input_task(
         assert "reasoning" in run.intermediate_outputs
         assert isinstance(run.intermediate_outputs["reasoning"], str)
 
+    # Check the trace
+    trace = run.trace
+    assert trace is not None
+    if verify_trace_cot:
+        assert len(trace) == 5
+        assert trace[0]["role"] == "system"
+        assert "You are an assistant which classifies a triangle" in trace[0]["content"]
+        assert trace[1]["role"] == "user"
+        assert trace[2]["role"] == "assistant"
+        assert trace[2].get("tool_calls") is None
+        assert trace[3]["role"] == "user"
+        assert trace[4]["role"] == "assistant"
+        assert trace[4].get("tool_calls") is None
+    else:
+        assert len(trace) == 3
+        assert trace[0]["role"] == "system"
+        assert "You are an assistant which classifies a triangle" in trace[0]["content"]
+        assert trace[1]["role"] == "user"
+        json_content = json.loads(trace[1]["content"])
+        assert json_content["a"] == 2
+        assert json_content["b"] == 2
+        assert json_content["c"] == 2
+        assert trace[2]["role"] == "assistant"
+        assert trace[2].get("tool_calls") is None
+        assert "[[equilateral]]" in trace[2]["content"]
+
 
 @pytest.mark.paid
 async def test_structured_input_gpt_4o_mini(tmp_path):
@@ -299,15 +328,94 @@ async def test_all_built_in_models_structured_input(
     )
 
 
+async def test_all_built_in_models_structured_input_mocked(tmp_path):
+    mock_response = ModelResponse(
+        model="gpt-4o-mini",
+        choices=[
+            {
+                "message": {
+                    "content": "The answer is [[equilateral]]",
+                }
+            }
+        ],
+    )
+
+    # Mock the Config.shared() method to return a mock config with required attributes
+    mock_config = Mock()
+    mock_config.open_ai_api_key = "mock_api_key"
+    mock_config.user_id = "test_user"
+    mock_config.groq_api_key = "mock_api_key"
+
+    with (
+        patch(
+            "litellm.acompletion",
+            side_effect=[mock_response],
+        ),
+        patch("kiln_ai.utils.config.Config.shared", return_value=mock_config),
+    ):
+        await run_structured_input_test(
+            tmp_path, "llama_3_1_8b", "groq", "simple_prompt_builder"
+        )
+
+
 @pytest.mark.paid
 @pytest.mark.ollama
 @pytest.mark.parametrize("model_name,provider_name", get_all_models_and_providers())
 async def test_structured_input_cot_prompt_builder(tmp_path, model_name, provider_name):
     task = build_structured_input_test_task(tmp_path)
     await run_structured_input_task(
-        task, model_name, provider_name, "simple_chain_of_thought_prompt_builder"
+        task,
+        model_name,
+        provider_name,
+        "simple_chain_of_thought_prompt_builder",
+        verify_trace_cot=True,
+    )
+
+
+async def test_structured_input_cot_prompt_builder_mocked(tmp_path):
+    task = build_structured_input_test_task(tmp_path)
+    mock_response_1 = ModelResponse(
+        model="gpt-4o-mini",
+        choices=[
+            {
+                "message": {
+                    "content": "I'm thinking real hard... oh!",
+                }
+            }
+        ],
+    )
+    mock_response_2 = ModelResponse(
+        model="gpt-4o-mini",
+        choices=[
+            {
+                "message": {
+                    "content": "After thinking, I've decided the answer is [[equilateral]]",
+                }
+            }
+        ],
     )
 
+    # Mock the Config.shared() method to return a mock config with required attributes
+    mock_config = Mock()
+    mock_config.open_ai_api_key = "mock_api_key"
+    mock_config.user_id = "test_user"
+    mock_config.groq_api_key = "mock_api_key"
+
+    with (
+        patch(
+            "litellm.acompletion",
+            side_effect=[mock_response_1, mock_response_2],
+        ),
+        patch("kiln_ai.utils.config.Config.shared", return_value=mock_config),
+    ):
+        await run_structured_input_task(
+            task,
+            "llama_3_1_8b",
+            "groq",
+            "simple_chain_of_thought_prompt_builder",
+            verify_trace_cot=True,
+        )
+
 
 @pytest.mark.paid
 @pytest.mark.ollama
@@ -350,7 +458,7 @@ When asked for a final result, this is the format (for an equilateral example):
 """
     task.output_json_schema = json.dumps(triangle_schema)
     task.save_to_file()
-    response, adapter, _ = await run_structured_input_task_no_validation(
+    response, _, _ = await run_structured_input_task_no_validation(
         task, model_name, provider_name, "simple_chain_of_thought_prompt_builder"
     )
 

kiln_ai/adapters/ollama_tools.py

@@ -4,6 +4,7 @@ import httpx
 import requests
 from pydantic import BaseModel, Field
 
+from kiln_ai.adapters.ml_embedding_model_list import built_in_embedding_models
 from kiln_ai.adapters.ml_model_list import ModelProviderName, built_in_models
 from kiln_ai.utils.config import Config
 
@@ -41,22 +42,28 @@ class OllamaConnection(BaseModel):
     version: str | None = None
     supported_models: List[str]
     untested_models: List[str] = Field(default_factory=list)
+    supported_embedding_models: List[str] = Field(default_factory=list)
 
     def all_models(self) -> List[str]:
         return self.supported_models + self.untested_models
 
+    def all_embedding_models(self) -> List[str]:
+        return self.supported_embedding_models
+
 
 # Parse the Ollama /api/tags response
-def parse_ollama_tags(tags: Any) -> OllamaConnection | None:
+def parse_ollama_tags(tags: Any) -> OllamaConnection:
     # Build a list of models we support for Ollama from the built-in model list
-    supported_ollama_models = [
-        provider.model_id
-        for model in built_in_models
-        for provider in model.providers
-        if provider.name == ModelProviderName.ollama
-    ]
+    supported_ollama_models = set(
+        [
+            provider.model_id
+            for model in built_in_models
+            for provider in model.providers
+            if provider.name == ModelProviderName.ollama
+        ]
+    )
     # Append model_aliases to supported_ollama_models
-    supported_ollama_models.extend(
+    supported_ollama_models.update(
         [
             alias
             for model in built_in_models
@@ -65,16 +72,44 @@ def parse_ollama_tags(tags: Any) -> OllamaConnection | None:
         ]
     )
 
+    supported_ollama_embedding_models = set(
+        [
+            provider.model_id
+            for model in built_in_embedding_models
+            for provider in model.providers
+            if provider.name == ModelProviderName.ollama
+        ]
+    )
+    supported_ollama_embedding_models.update(
+        [
+            alias
+            for model in built_in_embedding_models
+            for provider in model.providers
+            for alias in provider.ollama_model_aliases or []
+        ]
+    )
+
     if "models" in tags:
         models = tags["models"]
         if isinstance(models, list):
             model_names = [model["model"] for model in models]
             available_supported_models = []
             untested_models = []
-            supported_models_latest_aliases = [
-                f"{m}:latest" for m in supported_ollama_models
-            ]
+            supported_models_latest_aliases = set(
+                [f"{m}:latest" for m in supported_ollama_models]
+            )
+            supported_embedding_models_latest_aliases = set(
+                [f"{m}:latest" for m in supported_ollama_embedding_models]
+            )
+
             for model in model_names:
+                # Skip embedding models - they should only appear in supported_embedding_models
+                if (
+                    model in supported_ollama_embedding_models
+                    or model in supported_embedding_models_latest_aliases
+                ):
+                    continue
+
                 if (
                     model in supported_ollama_models
                     or model in supported_models_latest_aliases
@@ -83,17 +118,31 @@ def parse_ollama_tags(tags: Any) -> OllamaConnection | None:
                 else:
                     untested_models.append(model)
 
-            if available_supported_models or untested_models:
+            available_supported_embedding_models = []
+            for model in model_names:
+                if (
+                    model in supported_ollama_embedding_models
+                    or model in supported_embedding_models_latest_aliases
+                ):
+                    available_supported_embedding_models.append(model)
+
+            if (
+                available_supported_models
+                or untested_models
+                or available_supported_embedding_models
+            ):
                 return OllamaConnection(
                     message="Ollama connected",
                     supported_models=available_supported_models,
                     untested_models=untested_models,
+                    supported_embedding_models=available_supported_embedding_models,
                 )
 
     return OllamaConnection(
         message="Ollama is running, but no supported models are installed. Install one or more supported model, like 'ollama pull phi3.5'.",
         supported_models=[],
         untested_models=[],
+        supported_embedding_models=[],
     )
 
 
@@ -113,3 +162,11 @@ async def get_ollama_connection() -> OllamaConnection | None:
 def ollama_model_installed(conn: OllamaConnection, model_name: str) -> bool:
     all_models = conn.all_models()
     return model_name in all_models or f"{model_name}:latest" in all_models
+
+
+def ollama_embedding_model_installed(conn: OllamaConnection, model_name: str) -> bool:
+    all_embedding_models = conn.all_embedding_models()
+    return (
+        model_name in all_embedding_models
+        or f"{model_name}:latest" in all_embedding_models
+    )

kiln_ai/adapters/parsers/__init__.py

@@ -7,4 +7,4 @@ Parsing utilities for JSON and models with custom output formats (R1, etc.)
 
 from . import base_parser, json_parser, r1_parser
 
-__all__ = ["r1_parser", "base_parser", "json_parser"]
+__all__ = ["base_parser", "json_parser", "r1_parser"]

kiln_ai/adapters/provider_tools.py

@@ -1,7 +1,13 @@
 import logging
+import os
 from dataclasses import dataclass
 from typing import Dict, List
 
+from pydantic import BaseModel
+
+from kiln_ai.adapters.docker_model_runner_tools import (
+    get_docker_model_runner_connection,
+)
 from kiln_ai.adapters.ml_model_list import (
     KilnModel,
     KilnModelProvider,
@@ -10,14 +16,12 @@ from kiln_ai.adapters.ml_model_list import (
     StructuredOutputMode,
     built_in_models,
 )
-from kiln_ai.adapters.model_adapters.litellm_config import LiteLlmConfig
 from kiln_ai.adapters.ollama_tools import get_ollama_connection
 from kiln_ai.datamodel import Finetune, Task
 from kiln_ai.datamodel.datamodel_enums import ChatStrategy
-from kiln_ai.datamodel.registry import project_from_id
-from kiln_ai.datamodel.task import RunConfigProperties
 from kiln_ai.utils.config import Config
 from kiln_ai.utils.exhaustive_error import raise_exhaustive_enum_error
+from kiln_ai.utils.project_utils import project_from_id
 
 logger = logging.getLogger(__name__)
 
@@ -32,6 +36,15 @@ async def provider_enabled(provider_name: ModelProviderName) -> bool:
         except Exception:
             return False
 
+    if provider_name == ModelProviderName.docker_model_runner:
+        try:
+            conn = await get_docker_model_runner_connection()
+            return conn is not None and (
+                len(conn.supported_models) > 0 or len(conn.untested_models) > 0
+            )
+        except Exception:
+            return False
+
     provider_warning = provider_warnings.get(provider_name)
     if provider_warning is None:
         return False
@@ -180,50 +193,6 @@ def kiln_model_provider_from(
     )
 
 
-def lite_llm_config_for_openai_compatible(
-    run_config_properties: RunConfigProperties,
-) -> LiteLlmConfig:
-    model_id = run_config_properties.model_name
-    try:
-        openai_provider_name, model_id = model_id.split("::")
-    except Exception:
-        raise ValueError(f"Invalid openai compatible model ID: {model_id}")
-
-    openai_compatible_providers = Config.shared().openai_compatible_providers or []
-    provider = next(
-        filter(
-            lambda p: p.get("name") == openai_provider_name, openai_compatible_providers
-        ),
-        None,
-    )
-    if provider is None:
-        raise ValueError(f"OpenAI compatible provider {openai_provider_name} not found")
-
-    # API key optional - some providers like Ollama don't use it, but LiteLLM errors without one
-    api_key = provider.get("api_key") or "NA"
-    base_url = provider.get("base_url")
-    if base_url is None:
-        raise ValueError(
-            f"OpenAI compatible provider {openai_provider_name} has no base URL"
-        )
-
-    # Update a copy of the run config properties to use the openai compatible provider
-    updated_run_config_properties = run_config_properties.model_copy(deep=True)
-    updated_run_config_properties.model_provider_name = (
-        ModelProviderName.openai_compatible
-    )
-    updated_run_config_properties.model_name = model_id
-
-    return LiteLlmConfig(
-        # OpenAI compatible, with a custom base URL
-        run_config_properties=updated_run_config_properties,
-        base_url=base_url,
-        additional_body_options={
-            "api_key": api_key,
-        },
-    )
-
-
 def lite_llm_provider_model(
     model_id: str,
 ) -> KilnModelProvider:
@@ -377,6 +346,8 @@ def provider_name_from_id(id: str) -> str:
                 return "SiliconFlow"
             case ModelProviderName.cerebras:
                 return "Cerebras"
+            case ModelProviderName.docker_model_runner:
+                return "Docker Model Runner"
             case _:
                 # triggers pyright warning if I miss a case
                 raise_exhaustive_enum_error(enum_id)
@@ -444,3 +415,190 @@ provider_warnings: Dict[ModelProviderName, ModelProviderWarning] = {
         message="Attempted to use Cerebras without an API key set. \nGet your API key from https://cloud.cerebras.ai/platform",
     ),
 }
+
+
+class LiteLlmCoreConfig(BaseModel):
+    base_url: str | None = None
+    default_headers: Dict[str, str] | None = None
+    additional_body_options: Dict[str, str] | None = None
+
+
+def lite_llm_core_config_for_provider(
+    provider_name: ModelProviderName,
+    openai_compatible_provider_name: str | None = None,
+) -> LiteLlmCoreConfig | None:
+    """
+    Returns a LiteLLM core config for a given provider.
+
+    Args:
+        provider_name: The provider to get the config for
+        openai_compatible_provider_name: Required for openai compatible providers, this is the name of the underlying provider
+    """
+    match provider_name:
+        case ModelProviderName.openrouter:
+            return LiteLlmCoreConfig(
+                base_url=(
+                    os.getenv("OPENROUTER_BASE_URL") or "https://openrouter.ai/api/v1"
+                ),
+                default_headers={
+                    "HTTP-Referer": "https://kiln.tech/openrouter",
+                    "X-Title": "KilnAI",
+                },
+                additional_body_options={
+                    "api_key": Config.shared().open_router_api_key,
+                },
+            )
+        case ModelProviderName.siliconflow_cn:
+            return LiteLlmCoreConfig(
+                base_url=os.getenv("SILICONFLOW_BASE_URL")
+                or "https://api.siliconflow.cn/v1",
+                default_headers={
+                    "HTTP-Referer": "https://kiln.tech/siliconflow",
+                    "X-Title": "KilnAI",
+                },
+                additional_body_options={
+                    "api_key": Config.shared().siliconflow_cn_api_key,
+                },
+            )
+        case ModelProviderName.openai:
+            return LiteLlmCoreConfig(
+                additional_body_options={
+                    "api_key": Config.shared().open_ai_api_key,
+                },
+            )
+        case ModelProviderName.groq:
+            return LiteLlmCoreConfig(
+                additional_body_options={
+                    "api_key": Config.shared().groq_api_key,
+                },
+            )
+        case ModelProviderName.amazon_bedrock:
+            return LiteLlmCoreConfig(
+                additional_body_options={
+                    "aws_access_key_id": Config.shared().bedrock_access_key,
+                    "aws_secret_access_key": Config.shared().bedrock_secret_key,
+                    # The only region that's widely supported for bedrock
+                    "aws_region_name": "us-west-2",
+                },
+            )
+        case ModelProviderName.ollama:
+            # Set the Ollama base URL for 2 reasons:
+            # 1. To use the correct base URL
+            # 2. We use Ollama's OpenAI compatible API (/v1), and don't just let litellm use the Ollama API. We use more advanced features like json_schema.
+            ollama_base_url = (
+                Config.shared().ollama_base_url or "http://localhost:11434"
+            )
+            return LiteLlmCoreConfig(
+                base_url=ollama_base_url + "/v1",
+                additional_body_options={
+                    # LiteLLM errors without an api_key, even though Ollama doesn't support one
+                    "api_key": "NA",
+                },
+            )
+        case ModelProviderName.docker_model_runner:
+            docker_base_url = (
+                Config.shared().docker_model_runner_base_url
+                or "http://localhost:12434/engines/llama.cpp"
+            )
+            return LiteLlmCoreConfig(
+                # Docker Model Runner uses OpenAI-compatible API at /v1 endpoint
+                base_url=docker_base_url + "/v1",
+                additional_body_options={
+                    # LiteLLM errors without an api_key, even though Docker Model Runner doesn't require one.
+                    "api_key": "DMR",
+                },
+            )
+        case ModelProviderName.fireworks_ai:
+            return LiteLlmCoreConfig(
+                additional_body_options={
+                    "api_key": Config.shared().fireworks_api_key,
+                },
+            )
+        case ModelProviderName.anthropic:
+            return LiteLlmCoreConfig(
+                additional_body_options={
+                    "api_key": Config.shared().anthropic_api_key,
+                },
+            )
+        case ModelProviderName.gemini_api:
+            return LiteLlmCoreConfig(
+                additional_body_options={
+                    "api_key": Config.shared().gemini_api_key,
+                },
+            )
+        case ModelProviderName.vertex:
+            return LiteLlmCoreConfig(
+                additional_body_options={
+                    "vertex_project": Config.shared().vertex_project_id,
+                    "vertex_location": Config.shared().vertex_location,
+                },
+            )
+        case ModelProviderName.together_ai:
+            return LiteLlmCoreConfig(
+                additional_body_options={
+                    "api_key": Config.shared().together_api_key,
+                },
+            )
+        case ModelProviderName.azure_openai:
+            return LiteLlmCoreConfig(
+                base_url=Config.shared().azure_openai_endpoint,
+                additional_body_options={
+                    "api_key": Config.shared().azure_openai_api_key,
+                    "api_version": "2025-02-01-preview",
+                },
+            )
+        case ModelProviderName.huggingface:
+            return LiteLlmCoreConfig(
+                additional_body_options={
+                    "api_key": Config.shared().huggingface_api_key,
+                },
+            )
+        case ModelProviderName.cerebras:
+            return LiteLlmCoreConfig(
+                additional_body_options={
+                    "api_key": Config.shared().cerebras_api_key,
+                },
+            )
+        case ModelProviderName.openai_compatible:
+            # openai compatible requires a model name in the format "provider::model_name"
+            if openai_compatible_provider_name is None:
+                raise ValueError("OpenAI compatible provider requires a provider name")
+
+            openai_compatible_providers = (
+                Config.shared().openai_compatible_providers or []
+            )
+
+            provider = next(
+                filter(
+                    lambda p: p.get("name") == openai_compatible_provider_name,
+                    openai_compatible_providers,
+                ),
+                None,
+            )
+
+            if provider is None:
+                raise ValueError(
+                    f"OpenAI compatible provider {openai_compatible_provider_name} not found"
+                )
+
+            # API key optional - some providers like Ollama don't use it, but LiteLLM errors without one
+            api_key = provider.get("api_key") or "NA"
+            base_url = provider.get("base_url")
+            if base_url is None:
+                raise ValueError(
+                    f"OpenAI compatible provider {openai_compatible_provider_name} has no base URL"
+                )
+
+            return LiteLlmCoreConfig(
+                base_url=base_url,
+                additional_body_options={
+                    "api_key": api_key,
+                },
+            )
+        # These are virtual providers that should have mapped to an actual provider upstream (using core_provider method)
+        case ModelProviderName.kiln_fine_tune:
+            return None
+        case ModelProviderName.kiln_custom_registry:
+            return None
+        case _:
+            raise_exhaustive_enum_error(provider_name)

kiln_ai/adapters/rag/deduplication.py

@@ -0,0 +1,49 @@
+from collections import defaultdict
+from typing import DefaultDict
+
+from kiln_ai.datamodel.chunk import ChunkedDocument
+from kiln_ai.datamodel.embedding import ChunkEmbeddings
+from kiln_ai.datamodel.extraction import Document, Extraction
+
+
+def deduplicate_extractions(items: list[Extraction]) -> list[Extraction]:
+    grouped_items: DefaultDict[str, list[Extraction]] = defaultdict(list)
+    for item in items:
+        if item.extractor_config_id is None:
+            raise ValueError("Extractor config ID is required")
+        grouped_items[item.extractor_config_id].append(item)
+    return [min(group, key=lambda x: x.created_at) for group in grouped_items.values()]
+
+
+def deduplicate_chunked_documents(
+    items: list[ChunkedDocument],
+) -> list[ChunkedDocument]:
+    grouped_items: DefaultDict[str, list[ChunkedDocument]] = defaultdict(list)
+    for item in items:
+        if item.chunker_config_id is None:
+            raise ValueError("Chunker config ID is required")
+        grouped_items[item.chunker_config_id].append(item)
+    return [min(group, key=lambda x: x.created_at) for group in grouped_items.values()]
+
+
+def deduplicate_chunk_embeddings(items: list[ChunkEmbeddings]) -> list[ChunkEmbeddings]:
+    grouped_items: DefaultDict[str, list[ChunkEmbeddings]] = defaultdict(list)
+    for item in items:
+        if item.embedding_config_id is None:
+            raise ValueError("Embedding config ID is required")
+        grouped_items[item.embedding_config_id].append(item)
+    return [min(group, key=lambda x: x.created_at) for group in grouped_items.values()]
+
+
+def filter_documents_by_tags(
+    documents: list[Document], tags: list[str] | None
+) -> list[Document]:
+    if not tags:
+        return documents
+
+    filtered_documents = []
+    for document in documents:
+        if document.tags and any(tag in document.tags for tag in tags):
+            filtered_documents.append(document)
+
+    return filtered_documents