ragit 0.8.2__tar.gz → 0.10.1__tar.gz

{ragit-0.8.2/ragit.egg-info → ragit-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragit
-Version: 0.8.2
+Version: 0.10.1
 Summary: Automatic RAG Pattern Optimization Engine
 Author: RODMENA LIMITED
 Maintainer-email: RODMENA LIMITED <info@rodmena.co.uk>
@@ -16,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: POSIX :: Linux
-Requires-Python: <3.14,>=3.12
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.31.0
@@ -28,6 +28,7 @@ Requires-Dist: scikit-learn>=1.5.0
 Requires-Dist: tqdm>=4.66.0
 Requires-Dist: trio>=0.24.0
 Requires-Dist: httpx>=0.27.0
+Requires-Dist: resilient-circuit>=0.4.7
 Provides-Extra: dev
 Requires-Dist: ragit[test]; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
@@ -39,8 +40,6 @@ Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: pytest-mock; extra == "test"
-Provides-Extra: transformers
-Requires-Dist: sentence-transformers>=2.2.0; extra == "transformers"
 Provides-Extra: docs
 Requires-Dist: sphinx>=7.0; extra == "docs"
 Requires-Dist: sphinx-rtd-theme>=2.0; extra == "docs"
@@ -55,14 +54,11 @@ RAG toolkit for Python. Document loading, chunking, vector search, LLM integrati
 
 ```bash
 pip install ragit
-
-# For offline embedding
-pip install ragit[transformers]
 ```
 
 ## Quick Start
 
-You must provide an embedding source: custom function, SentenceTransformers, or any provider.
+You must provide an embedding source: custom function, Ollama, or any provider.
 
 ### Custom Embedding Function
 
@@ -90,26 +86,17 @@ assistant = RAGAssistant("docs/", embed_fn=my_embed, generate_fn=my_generate)
 answer = assistant.ask("How does authentication work?")
 ```
 
-### Offline Embedding (SentenceTransformers)
-
-Models are downloaded automatically on first use (~90MB for default model).
+### With Ollama (nomic-embed-text)
 
 ```python
 from ragit import RAGAssistant
-from ragit.providers import SentenceTransformersProvider
+from ragit.providers import OllamaProvider
 
-# Uses all-MiniLM-L6-v2 by default
-assistant = RAGAssistant("docs/", provider=SentenceTransformersProvider())
-
-# Or specify a model
-assistant = RAGAssistant(
-    "docs/",
-    provider=SentenceTransformersProvider(model_name="all-mpnet-base-v2")
-)
+# Uses nomic-embed-text for embeddings (768d)
+assistant = RAGAssistant("docs/", provider=OllamaProvider())
+results = assistant.retrieve("search query")
 ```
 
-Available models: `all-MiniLM-L6-v2` (384d), `all-mpnet-base-v2` (768d), `paraphrase-MiniLM-L6-v2` (384d)
-
 ## Core API
 
 ```python

{ragit-0.8.2 → ragit-0.10.1}/README.md

@@ -6,14 +6,11 @@ RAG toolkit for Python. Document loading, chunking, vector search, LLM integrati
 
 ```bash
 pip install ragit
-
-# For offline embedding
-pip install ragit[transformers]
 ```
 
 ## Quick Start
 
-You must provide an embedding source: custom function, SentenceTransformers, or any provider.
+You must provide an embedding source: custom function, Ollama, or any provider.
 
 ### Custom Embedding Function
 
@@ -41,26 +38,17 @@ assistant = RAGAssistant("docs/", embed_fn=my_embed, generate_fn=my_generate)
 answer = assistant.ask("How does authentication work?")
 ```
 
-### Offline Embedding (SentenceTransformers)
-
-Models are downloaded automatically on first use (~90MB for default model).
+### With Ollama (nomic-embed-text)
 
 ```python
 from ragit import RAGAssistant
-from ragit.providers import SentenceTransformersProvider
+from ragit.providers import OllamaProvider
 
-# Uses all-MiniLM-L6-v2 by default
-assistant = RAGAssistant("docs/", provider=SentenceTransformersProvider())
-
-# Or specify a model
-assistant = RAGAssistant(
-    "docs/",
-    provider=SentenceTransformersProvider(model_name="all-mpnet-base-v2")
-)
+# Uses nomic-embed-text for embeddings (768d)
+assistant = RAGAssistant("docs/", provider=OllamaProvider())
+results = assistant.retrieve("search query")
 ```
 
-Available models: `all-MiniLM-L6-v2` (384d), `all-mpnet-base-v2` (768d), `paraphrase-MiniLM-L6-v2` (384d)
-
 ## Core API
 
 ```python

{ragit-0.8.2 → ragit-0.10.1}/pyproject.toml

@@ -10,7 +10,7 @@ maintainers = [
     { name = "RODMENA LIMITED", email = "info@rodmena.co.uk" },
 ]
 readme = "README.md"
-requires-python = ">=3.12,<3.14"
+requires-python = ">=3.12"
 classifiers = [
     "Development Status :: 2 - Pre-Alpha",
     "Natural Language :: English",
@@ -40,6 +40,7 @@ dependencies = [
     "tqdm>=4.66.0",
     "trio>=0.24.0",
     "httpx>=0.27.0",
+    "resilient-circuit>=0.4.7",
 ]
 
 [project.urls]
@@ -59,8 +60,6 @@ dev = [
 
 test = ["pytest", "pytest-cov", "pytest-mock"]
 
-transformers = ["sentence-transformers>=2.2.0"]
-
 docs = [
     "sphinx>=7.0",
     "sphinx-rtd-theme>=2.0",

{ragit-0.8.2 → ragit-0.10.1}/ragit/__init__.py

@@ -16,11 +16,7 @@ Quick Start
 >>> assistant = RAGAssistant("docs/", embed_fn=my_embed)
 >>> results = assistant.retrieve("How do I create a REST API?")
 >>>
->>> # With SentenceTransformers (offline, requires ragit[transformers])
->>> from ragit.providers import SentenceTransformersProvider
->>> assistant = RAGAssistant("docs/", provider=SentenceTransformersProvider())
->>>
->>> # With Ollama (explicit)
+>>> # With Ollama
 >>> from ragit.providers import OllamaProvider
 >>> assistant = RAGAssistant("docs/", provider=OllamaProvider())
 >>> answer = assistant.ask("How do I create a REST API?")
@@ -63,14 +59,27 @@ from ragit.core.experiment.experiment import (  # noqa: E402
     RagitExperiment,
 )
 from ragit.core.experiment.results import EvaluationResult, ExperimentResults  # noqa: E402
+from ragit.exceptions import (  # noqa: E402
+    ConfigurationError,
+    EvaluationError,
+    ExceptionAggregator,
+    GenerationError,
+    IndexingError,
+    ProviderError,
+    RagitError,
+    RetrievalError,
+)
 from ragit.loaders import (  # noqa: E402
     chunk_by_separator,
     chunk_document,
     chunk_rst_sections,
     chunk_text,
+    deduplicate_documents,
+    generate_document_id,
     load_directory,
     load_text,
 )
+from ragit.monitor import ExecutionMonitor  # noqa: E402
 from ragit.providers import (  # noqa: E402
     BaseEmbeddingProvider,
     BaseLLMProvider,
@@ -89,6 +98,8 @@ __all__ = [
     "chunk_document",
     "chunk_by_separator",
     "chunk_rst_sections",
+    "generate_document_id",
+    "deduplicate_documents",
     # Core classes
     "Document",
     "Chunk",
@@ -97,6 +108,17 @@ __all__ = [
     "FunctionProvider",
     "BaseLLMProvider",
     "BaseEmbeddingProvider",
+    # Exceptions
+    "RagitError",
+    "ConfigurationError",
+    "ProviderError",
+    "IndexingError",
+    "RetrievalError",
+    "GenerationError",
+    "EvaluationError",
+    "ExceptionAggregator",
+    # Monitoring
+    "ExecutionMonitor",
     # Optimization
     "RagitExperiment",
     "BenchmarkQuestion",
@@ -104,13 +126,3 @@ __all__ = [
     "EvaluationResult",
     "ExperimentResults",
 ]
-
-# Conditionally add SentenceTransformersProvider if available
-try:
-    from ragit.providers import (  # noqa: E402
-        SentenceTransformersProvider as SentenceTransformersProvider,
-    )
-
-    __all__ += ["SentenceTransformersProvider"]
-except ImportError:
-    pass

{ragit-0.8.2 → ragit-0.10.1}/ragit/assistant.py

@@ -19,6 +19,7 @@ from numpy.typing import NDArray
 
 from ragit.core.experiment.experiment import Chunk, Document
 from ragit.loaders import chunk_document, chunk_rst_sections, load_directory, load_text
+from ragit.logging import log_operation
 from ragit.providers.base import BaseEmbeddingProvider, BaseLLMProvider
 from ragit.providers.function_adapter import FunctionProvider
 
@@ -76,13 +77,9 @@ class RAGAssistant:
     >>> assistant = RAGAssistant(docs, embed_fn=my_embed, generate_fn=my_llm)
     >>> answer = assistant.ask("What is X?")
     >>>
-    >>> # With explicit provider
+    >>> # With Ollama provider (supports nomic-embed-text)
     >>> from ragit.providers import OllamaProvider
     >>> assistant = RAGAssistant(docs, provider=OllamaProvider())
-    >>>
-    >>> # With SentenceTransformers (offline)
-    >>> from ragit.providers import SentenceTransformersProvider
-    >>> assistant = RAGAssistant(docs, provider=SentenceTransformersProvider())
     """
 
     def __init__(
@@ -126,8 +123,7 @@ class RAGAssistant:
                 "Must provide embed_fn or provider for embeddings. "
                 "Examples:\n"
                 "  RAGAssistant(docs, embed_fn=my_embed_function)\n"
-                "  RAGAssistant(docs, provider=OllamaProvider())\n"
-                "  RAGAssistant(docs, provider=SentenceTransformersProvider())"
+                "  RAGAssistant(docs, provider=OllamaProvider())"
             )
 
         self.embedding_model = embedding_model or "default"
@@ -181,7 +177,7 @@ class RAGAssistant:
         for doc in self.documents:
             # Use RST section chunking for .rst files, otherwise regular chunking
             if doc.metadata.get("filename", "").endswith(".rst"):
-                chunks = chunk_rst_sections(doc.content, doc.id, metadata=doc.metadata)
+                chunks = chunk_rst_sections(doc.content, doc.id)
             else:
                 chunks = chunk_document(doc, self.chunk_size, self.chunk_overlap)
             all_chunks.extend(chunks)
@@ -225,7 +221,7 @@ class RAGAssistant:
         new_chunks: list[Chunk] = []
         for doc in new_docs:
             if doc.metadata.get("filename", "").endswith(".rst"):
-                chunks = chunk_rst_sections(doc.content, doc.id, metadata=doc.metadata)
+                chunks = chunk_rst_sections(doc.content, doc.id)
             else:
                 chunks = chunk_document(doc, self.chunk_size, self.chunk_overlap)
             new_chunks.extend(chunks)
@@ -378,6 +374,190 @@ class RAGAssistant:
 
         return [(self._chunks[i], float(similarities[i])) for i in top_indices]
 
+    def retrieve_with_context(
+        self,
+        query: str,
+        top_k: int = 3,
+        window_size: int = 1,
+        min_score: float = 0.0,
+    ) -> list[tuple[Chunk, float]]:
+        """
+        Retrieve chunks with adjacent context expansion (window search).
+
+        For each retrieved chunk, also includes adjacent chunks from the
+        same document to provide more context. This is useful when relevant
+        information spans multiple chunks.
+
+        Pattern inspired by ai4rag window_search.
+
+        Parameters
+        ----------
+        query : str
+            Search query.
+        top_k : int
+            Number of initial chunks to retrieve (default: 3).
+        window_size : int
+            Number of adjacent chunks to include on each side (default: 1).
+            Set to 0 to disable window expansion.
+        min_score : float
+            Minimum similarity score threshold (default: 0.0).
+
+        Returns
+        -------
+        list[tuple[Chunk, float]]
+            List of (chunk, similarity_score) tuples, sorted by relevance.
+            Adjacent chunks have slightly lower scores.
+
+        Examples
+        --------
+        >>> # Get chunks with 1 adjacent chunk on each side
+        >>> results = assistant.retrieve_with_context("query", window_size=1)
+        >>> for chunk, score in results:
+        ...     print(f"{score:.2f}: {chunk.content[:50]}...")
+        """
+        with log_operation("retrieve_with_context", query_len=len(query), top_k=top_k, window_size=window_size) as ctx:
+            # Get initial results (more than top_k to account for filtering)
+            results = self.retrieve(query, top_k * 2)
+
+            # Apply minimum score threshold
+            if min_score > 0:
+                results = [(chunk, score) for chunk, score in results if score >= min_score]
+
+            if window_size == 0 or not results:
+                ctx["expanded_chunks"] = len(results)
+                return results[:top_k]
+
+            # Build chunk index for fast lookup
+            chunk_to_idx = {id(chunk): i for i, chunk in enumerate(self._chunks)}
+
+            expanded_results: list[tuple[Chunk, float]] = []
+            seen_indices: set[int] = set()
+
+            for chunk, score in results[:top_k]:
+                chunk_idx = chunk_to_idx.get(id(chunk))
+                if chunk_idx is None:
+                    expanded_results.append((chunk, score))
+                    continue
+
+                # Get window of adjacent chunks from same document
+                start_idx = max(0, chunk_idx - window_size)
+                end_idx = min(len(self._chunks), chunk_idx + window_size + 1)
+
+                for idx in range(start_idx, end_idx):
+                    if idx in seen_indices:
+                        continue
+
+                    adjacent_chunk = self._chunks[idx]
+                    # Only include adjacent chunks from same document
+                    if adjacent_chunk.doc_id == chunk.doc_id:
+                        seen_indices.add(idx)
+                        # Original chunk keeps full score, adjacent get 80%
+                        adj_score = score if idx == chunk_idx else score * 0.8
+                        expanded_results.append((adjacent_chunk, adj_score))
+
+            # Sort by score (highest first)
+            expanded_results.sort(key=lambda x: (-x[1], self._chunks.index(x[0]) if x[0] in self._chunks else 0))
+            ctx["expanded_chunks"] = len(expanded_results)
+
+            return expanded_results
+
+    def get_context_with_window(
+        self,
+        query: str,
+        top_k: int = 3,
+        window_size: int = 1,
+        min_score: float = 0.0,
+    ) -> str:
+        """
+        Get formatted context with adjacent chunk expansion.
+
+        Merges overlapping text from adjacent chunks intelligently.
+
+        Parameters
+        ----------
+        query : str
+            Search query.
+        top_k : int
+            Number of initial chunks to retrieve.
+        window_size : int
+            Number of adjacent chunks on each side.
+        min_score : float
+            Minimum similarity score threshold.
+
+        Returns
+        -------
+        str
+            Formatted context string with merged chunks.
+        """
+        results = self.retrieve_with_context(query, top_k, window_size, min_score)
+
+        if not results:
+            return ""
+
+        # Group chunks by document to merge properly
+        doc_chunks: dict[str, list[tuple[Chunk, float]]] = {}
+        for chunk, score in results:
+            doc_id = chunk.doc_id or "unknown"
+            if doc_id not in doc_chunks:
+                doc_chunks[doc_id] = []
+            doc_chunks[doc_id].append((chunk, score))
+
+        merged_sections: list[str] = []
+
+        for _doc_id, chunks in doc_chunks.items():
+            # Sort chunks by their position in the original list
+            chunks.sort(key=lambda x: self._chunks.index(x[0]) if x[0] in self._chunks else 0)
+
+            # Merge overlapping text
+            merged_content = []
+            for chunk, _ in chunks:
+                if merged_content:
+                    # Check for overlap with previous chunk
+                    prev_content = merged_content[-1]
+                    non_overlapping = self._get_non_overlapping_text(prev_content, chunk.content)
+                    if non_overlapping != chunk.content:
+                        # Found overlap, extend previous chunk
+                        merged_content[-1] = prev_content + non_overlapping
+                    else:
+                        # No overlap, add as new section
+                        merged_content.append(chunk.content)
+                else:
+                    merged_content.append(chunk.content)
+
+            merged_sections.append("\n".join(merged_content))
+
+        return "\n\n---\n\n".join(merged_sections)
+
+    def _get_non_overlapping_text(self, str1: str, str2: str) -> str:
+        """
+        Find non-overlapping portion of str2 when appending after str1.
+
+        Detects overlap where the end of str1 matches the beginning of str2,
+        and returns only the non-overlapping portion of str2.
+
+        Pattern from ai4rag vector_store/utils.py.
+
+        Parameters
+        ----------
+        str1 : str
+            First string (previous content).
+        str2 : str
+            Second string (content to potentially append).
+
+        Returns
+        -------
+        str
+            Non-overlapping portion of str2, or full str2 if no overlap.
+        """
+        # Limit overlap search to avoid O(n^2) for large strings
+        max_overlap = min(len(str1), len(str2), 200)
+
+        for i in range(max_overlap, 0, -1):
+            if str1[-i:] == str2[:i]:
+                return str2[i:]
+
+        return str2
+
     def get_context(self, query: str, top_k: int = 3) -> str:
         """
         Get formatted context string from retrieved chunks.

ragit-0.10.1/ragit/config.py

@@ -0,0 +1,204 @@
+#
+# Copyright RODMENA LIMITED 2025
+# SPDX-License-Identifier: Apache-2.0
+#
+"""
+Ragit configuration management with Pydantic validation.
+
+Loads configuration from environment variables and .env files.
+Validates all configuration values at startup.
+
+Note: As of v0.8.0, ragit no longer has default LLM or embedding models.
+Users must explicitly configure providers.
+"""
+
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+from pydantic import BaseModel, Field, field_validator
+
+# Note: We define ConfigValidationError locally to avoid circular imports,
+# but ragit.exceptions.ConfigurationError can be used elsewhere
+
+# Load .env file from current working directory or project root
+_env_path = Path.cwd() / ".env"
+if _env_path.exists():
+    load_dotenv(_env_path)
+else:
+    # Try to find .env in parent directories
+    for parent in Path.cwd().parents:
+        _env_path = parent / ".env"
+        if _env_path.exists():
+            load_dotenv(_env_path)
+            break
+
+
+class ConfigValidationError(Exception):
+    """Raised when configuration validation fails."""
+
+    pass
+
+
+class RagitConfig(BaseModel):
+    """Validated ragit configuration.
+
+    All configuration values are validated at startup. Invalid values
+    raise ConfigValidationError with a descriptive message.
+
+    Attributes
+    ----------
+    ollama_base_url : str
+        Ollama server URL (default: http://localhost:11434)
+    ollama_embedding_url : str
+        Embedding API URL (defaults to ollama_base_url)
+    ollama_api_key : str | None
+        API key for authentication
+    ollama_timeout : int
+        Request timeout in seconds (1-600)
+    default_llm_model : str | None
+        Default LLM model name
+    default_embedding_model : str | None
+        Default embedding model name
+    log_level : str
+        Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+    """
+
+    ollama_base_url: str = Field(default="http://localhost:11434")
+    ollama_embedding_url: str | None = None
+    ollama_api_key: str | None = None
+    ollama_timeout: int = Field(default=120, gt=0, le=600)
+    default_llm_model: str | None = None
+    default_embedding_model: str | None = None
+    log_level: str = Field(default="INFO")
+
+    @field_validator("ollama_base_url", "ollama_embedding_url", mode="before")
+    @classmethod
+    def validate_url(cls, v: str | None) -> str | None:
+        """Validate URL format."""
+        if v is None:
+            return v
+        v = str(v).strip().rstrip("/")
+        if not v:
+            return None
+        if not v.startswith(("http://", "https://")):
+            raise ValueError(f"URL must start with http:// or https://: {v}")
+        return v
+
+    @field_validator("log_level", mode="before")
+    @classmethod
+    def validate_log_level(cls, v: str) -> str:
+        """Validate log level is a valid Python logging level."""
+        valid_levels = {"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"}
+        v = str(v).upper().strip()
+        if v not in valid_levels:
+            raise ValueError(f"Invalid log level: {v}. Must be one of {valid_levels}")
+        return v
+
+    @field_validator("ollama_api_key", mode="before")
+    @classmethod
+    def validate_api_key(cls, v: str | None) -> str | None:
+        """Treat empty string as None."""
+        if v is not None and not str(v).strip():
+            return None
+        return v
+
+    @field_validator("ollama_timeout", mode="before")
+    @classmethod
+    def validate_timeout(cls, v: int | str) -> int:
+        """Parse and validate timeout value."""
+        try:
+            timeout = int(v)
+        except (ValueError, TypeError) as e:
+            raise ValueError(f"Invalid timeout value '{v}': must be an integer") from e
+        return timeout
+
+    model_config = {"extra": "forbid"}
+
+    # Uppercase aliases for backwards compatibility
+    @property
+    def OLLAMA_BASE_URL(self) -> str:
+        return self.ollama_base_url
+
+    @property
+    def OLLAMA_EMBEDDING_URL(self) -> str:
+        return self.ollama_embedding_url or self.ollama_base_url
+
+    @property
+    def OLLAMA_API_KEY(self) -> str | None:
+        return self.ollama_api_key
+
+    @property
+    def OLLAMA_TIMEOUT(self) -> int:
+        return self.ollama_timeout
+
+    @property
+    def DEFAULT_LLM_MODEL(self) -> str | None:
+        return self.default_llm_model
+
+    @property
+    def DEFAULT_EMBEDDING_MODEL(self) -> str | None:
+        return self.default_embedding_model
+
+    @property
+    def LOG_LEVEL(self) -> str:
+        return self.log_level
+
+
+def _safe_get_env(key: str, default: str | None = None) -> str | None:
+    """Get environment variable, returning None for empty strings."""
+    value = os.getenv(key, default)
+    if value is not None and not value.strip():
+        return default
+    return value
+
+
+def _safe_get_int_env(key: str, default: int) -> int | str:
+    """Get environment variable as int, returning raw string if invalid."""
+    value = os.getenv(key)
+    if value is None:
+        return default
+    try:
+        return int(value)
+    except ValueError:
+        # Return the raw string so Pydantic can give a better error message
+        return value
+
+
+def load_config() -> RagitConfig:
+    """Load and validate configuration from environment variables.
+
+    Returns
+    -------
+    RagitConfig
+        Validated configuration object.
+
+    Raises
+    ------
+    ConfigValidationError
+        If configuration validation fails.
+    """
+    try:
+        return RagitConfig(
+            ollama_base_url=_safe_get_env("OLLAMA_BASE_URL", "http://localhost:11434") or "http://localhost:11434",
+            ollama_embedding_url=_safe_get_env("OLLAMA_EMBEDDING_URL") or _safe_get_env("OLLAMA_BASE_URL"),
+            ollama_api_key=_safe_get_env("OLLAMA_API_KEY"),
+            ollama_timeout=_safe_get_int_env("OLLAMA_TIMEOUT", 120),
+            default_llm_model=_safe_get_env("RAGIT_DEFAULT_LLM_MODEL"),
+            default_embedding_model=_safe_get_env("RAGIT_DEFAULT_EMBEDDING_MODEL"),
+            log_level=_safe_get_env("RAGIT_LOG_LEVEL", "INFO") or "INFO",
+        )
+    except Exception as e:
+        raise ConfigValidationError(f"Configuration error: {e}") from e
+
+
+# Singleton instance - validates configuration at import time
+try:
+    config = load_config()
+except ConfigValidationError as e:
+    # Re-raise with clear message
+    raise ConfigValidationError(str(e)) from e
+
+
+# Backwards compatibility alias
+Config = RagitConfig

{ragit-0.8.2 → ragit-0.10.1}/ragit/core/experiment/experiment.py

@@ -45,7 +45,13 @@ class Document:
 
 @dataclass
 class Chunk:
-    """A document chunk."""
+    """A document chunk with optional rich metadata.
+
+    Metadata can include:
+    - document_id: SHA256 hash for deduplication and window search
+    - sequence_number: Order within the document
+    - chunk_start/chunk_end: Character positions in original text
+    """
 
     content: str
     doc_id: str