ragbandit-core 0.1.1__py3-none-any.whl

ragbandit/utils/llm_utils.py

@@ -0,0 +1,188 @@
+"""
+Utility functions for interacting with LLM services.
+
+This module provides standardized ways to make LLM requests with
+consistent error handling, retries, and response parsing.
+"""
+
+import json
+import time
+import logging
+import requests
+from typing import Type, TypeVar
+from pydantic import BaseModel
+from ragbandit.utils.mistral_client import mistral_client_manager
+from ragbandit.config.llms import (
+    DEFAULT_MODEL,
+    DEFAULT_TEMPERATURE,
+    DEFAULT_MAX_RETRIES,
+    DEFAULT_RETRY_DELAY,
+    DEFAULT_BACKOFF_FACTOR,
+)
+from ragbandit.utils.token_usage_tracker import TokenUsageTracker, count_tokens
+
+# Configure logger
+logger = logging.getLogger(__name__)
+
+# Type variable for Pydantic model return types
+T = TypeVar("T", bound=BaseModel)
+
+
+def query_llm(
+    prompt: str,
+    output_schema: Type[T],
+    api_key: str,
+    usage_tracker: TokenUsageTracker | None = None,
+    model: str = DEFAULT_MODEL,
+    temperature: float = DEFAULT_TEMPERATURE,
+    max_retries: int = DEFAULT_MAX_RETRIES,
+    retry_delay: float = DEFAULT_RETRY_DELAY,
+    backoff_factor: float = DEFAULT_BACKOFF_FACTOR,
+    track_usage: bool = True,
+) -> T:
+    """
+    Send a query to the LLM with standardized formatting and retry logic.
+
+    Args:
+        prompt: The prompt to send to the LLM
+        output_schema: Pydantic model class for response validation and parsing
+        api_key: API key to use for the request
+        usage_tracker: Optional custom token usage tracker for
+                       document-specific tracking.
+                       If None, no tracking will be performed even
+                       if track_usage is True.
+        model: Model name to use for the request
+        temperature: Sampling temperature (0 = deterministic)
+        max_retries: Maximum number of retry attempts
+        retry_delay: Initial delay between retries in seconds
+        backoff_factor: Multiplier for delay on each retry attempt
+        track_usage: Whether to track token usage and costs
+
+    Returns:
+        Validated instance of the output_schema model
+
+    Raises:
+        ValueError: If response cannot be parsed according to schema
+        RuntimeError: If all retry attempts fail
+    """
+    retry_count = 0
+    current_delay = retry_delay
+
+    # Only track usage if both conditions are met:
+    # 1. User wants to track usage (track_usage=True)
+    # 2. We have a tracker to use (usage_tracker is not None)
+    should_track = track_usage and usage_tracker is not None
+
+    # Count input tokens if tracking is enabled
+    input_tokens = 0
+    if should_track:
+        # Count tokens in the prompt
+        input_tokens = count_tokens(prompt, model)
+        logger.debug(f"Input tokens: {input_tokens} for model {model}")
+
+    while retry_count <= max_retries:
+        try:
+            # Make the API request
+            client = mistral_client_manager.get_client(api_key)
+            chat_response = client.chat.complete(
+                model=model,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": prompt,
+                    },
+                ],
+                response_format={
+                    "type": "json_object",
+                    "schema": output_schema.model_json_schema(),
+                },
+                temperature=temperature,
+            )
+
+            # Parse and validate the response
+            response_content = chat_response.choices[0].message.content
+            response_dict = json.loads(response_content)
+
+            # Track token usage if enabled
+            if should_track and hasattr(chat_response, 'usage'):
+                # Get token counts from the API response
+                output_tokens = chat_response.usage.completion_tokens
+                actual_input_tokens = chat_response.usage.prompt_tokens
+
+                # Use the actual input tokens from the API if available
+                if actual_input_tokens > 0:
+                    input_tokens = actual_input_tokens
+
+                # Log token usage
+                logger.debug(
+                    f"Token usage - Input: {input_tokens}, "
+                    f"Output: {output_tokens}, "
+                    f"Model: {model}"
+                )
+
+                # Track in the global usage tracker
+                usage_tracker.add_usage(input_tokens, output_tokens, model)
+            elif should_track:
+                # If API doesn't return usage stats, estimate output tokens
+                output_tokens = count_tokens(response_content, model)
+                usage_tracker.add_usage(input_tokens, output_tokens, model)
+                logger.debug(
+                    f"Estimated token usage - Input: {input_tokens}, "
+                    f"Output: {output_tokens}, "
+                    f"Model: {model}"
+                )
+
+            return output_schema.model_validate(response_dict)
+
+        except (requests.RequestException, TimeoutError, ConnectionError) as e:
+            # Handle network-related errors (timeouts, connection issues)
+            retry_count += 1
+
+            # If we've exhausted retries, raise the error
+            if retry_count > max_retries:
+                logger.error(f"Failed after {max_retries} retries: {str(e)}")
+                raise RuntimeError(
+                    f"LLM request failed after {max_retries} retries: {str(e)}"
+                )
+
+            # Log the error and retry
+            logger.warning(
+                "LLM request failed "
+                f"(attempt {retry_count}/{max_retries}): {str(e)}. "
+                f"Retrying in {current_delay} seconds..."
+            )
+            time.sleep(current_delay)
+            current_delay *= backoff_factor
+
+        except Exception as e:
+            # Handle other API errors (rate limits, server errors)
+            if "429" in str(e) or "too many requests" in str(e).lower():
+                # Rate limiting error - retry with backoff
+                retry_count += 1
+
+                if retry_count > max_retries:
+                    logger.error(
+                        (
+                            f"Rate limit exceeded after {max_retries} "
+                            f"retries: {str(e)}"
+                        )
+                    )
+                    raise RuntimeError(
+                        f"Rate limit exceeded after {max_retries} retries"
+                    )
+
+                logger.warning(
+                    f"Rate limit hit (attempt {retry_count}/{max_retries}). "
+                    f"Retrying in {current_delay} seconds..."
+                )
+                time.sleep(current_delay)
+                current_delay *= (
+                    backoff_factor * 2
+                )  # More aggressive backoff for rate limits
+            else:
+                # Other API errors - don't retry
+                logger.error(f"API error: {str(e)}")
+                raise RuntimeError(f"LLM API error: {str(e)}")
+
+    # This should never be reached due to the exception in the loop
+    raise RuntimeError("Unexpected error in LLM request retry loop")

ragbandit/utils/mistral_client.py

@@ -0,0 +1,76 @@
+"""
+Utility functions for working with the Mistral API.
+
+This module provides helper functions for creating and managing
+Mistral API client instances.
+
+The module exports a singleton instance of MistralClientManager as
+'mistral_client_manager' that should be used throughout the application
+to ensure consistent client caching and management.
+"""
+
+from mistralai import Mistral
+import logging
+
+# Configure logger
+logger = logging.getLogger(__name__)
+
+
+class MistralClientManager:
+    """
+    Manager class for Mistral API clients.
+
+    This class provides a way to cache and
+    reuse Mistral client instances
+    based on API keys, avoiding the need to
+    create a new client for each request.
+    """
+
+    def __init__(self):
+        """Initialize an empty client cache."""
+        self._clients: dict[str, Mistral] = {}
+
+    def get_mistral_client(self, api_key: str):
+        """
+        Get a configured Mistral client instance.
+
+        Returns:
+            Mistral: Configured client instance
+
+        Raises:
+            ValueError: If api_key is None
+        """
+        if not api_key or not api_key.strip():
+            raise ValueError("Mistral API key cannot be empty or None")
+        return Mistral(api_key=api_key)
+
+    def get_client(self, api_key: str) -> Mistral:
+        """
+        Get a Mistral client for the given API key.
+
+        If a client with this API key already exists in the cache,
+        it will be reused.
+        Otherwise, a new client will be created and cached.
+
+        Args:
+            api_key: Mistral API key to use for authentication
+
+        Returns:
+            Mistral: A configured Mistral client instance
+
+        Raises:
+            ValueError: If api_key is empty or None
+        """
+        # Hash the API key to use as a dictionary key
+        # This avoids storing the actual API key in memory as a dictionary key
+        key_hash = hash(api_key)
+
+        if key_hash not in self._clients:
+            # Create a new client and cache it
+            self._clients[key_hash] = self.get_mistral_client(api_key)
+
+        return self._clients[key_hash]
+
+
+# Global instance of the client manager
+mistral_client_manager = MistralClientManager()

ragbandit/utils/token_usage_tracker.py

@@ -0,0 +1,220 @@
+"""
+Cost tracking utilities for LLM API calls.
+
+This module provides functions to calculate token usage and costs
+for different LLM models.
+"""
+
+import logging
+import tiktoken
+from ragbandit.config.pricing import (
+    MODEL_COSTS,
+    EMBEDDING_COSTS,
+    DEFAULT_MODEL
+)
+from ragbandit.schema import TokenUsageMetrics
+
+# Configure logger
+logger = logging.getLogger(__name__)
+
+
+def count_tokens(text: str, model: str = DEFAULT_MODEL) -> int:
+    """
+    Count the number of tokens in a text string for a specific model.
+
+    Args:
+        text: The text to count tokens for
+        model: The model to use for token counting
+
+    Returns:
+        int: Number of tokens
+    """
+    try:
+        # For Mistral models, use cl100k_base encoding (same as GPT-4)
+        encoding = tiktoken.get_encoding("cl100k_base")
+        return len(encoding.encode(text))
+    except Exception as e:
+        logger.warning(
+            f"Error counting tokens: {e}. Using character-based estimate."
+        )
+        # Fallback: rough estimate based on characters (1 token ≈ 4 chars)
+        return len(text) // 4
+
+
+def calculate_cost(
+    input_tokens: int, output_tokens: int, model: str = DEFAULT_MODEL
+) -> tuple[float, dict[str, float]]:
+    """
+    Calculate the cost of an API call based on token usage.
+
+    Args:
+        input_tokens: Number of input tokens
+        output_tokens: Number of output tokens
+        model: Model name
+
+    Returns:
+        Tuple containing:
+            - Total cost in USD
+            - Dictionary with detailed cost breakdown
+    """
+    # Get cost rates, defaulting to mistral-small if model not found
+    input_rate, output_rate = MODEL_COSTS.get(
+        model, MODEL_COSTS[DEFAULT_MODEL]
+    )
+
+    # Calculate costs (rates are per 1M tokens)
+    input_cost = (input_tokens / 1_000_000) * input_rate
+    output_cost = (output_tokens / 1_000_000) * output_rate
+    total_cost = input_cost + output_cost
+
+    cost_details = {
+        "model": model,
+        "input_tokens": input_tokens,
+        "output_tokens": output_tokens,
+        "total_tokens": input_tokens + output_tokens,
+        "input_cost_usd": input_cost,
+        "output_cost_usd": output_cost,
+        "total_cost_usd": total_cost,
+    }
+
+    return total_cost, cost_details
+
+
+class TokenUsageTracker:
+    """Track token usage and costs across multiple API calls."""
+    total_input_tokens: int
+    total_output_tokens: int
+    total_embedding_tokens: int
+    total_cost: float
+    calls_by_model: dict[str, dict[str, int | float]]
+
+    def __init__(self):
+        self.total_input_tokens = 0
+        self.total_output_tokens = 0
+        self.total_embedding_tokens = 0
+        self.total_cost = 0.0
+        self.calls_by_model = {}
+
+    def add_usage(
+        self,
+        input_tokens: int,
+        output_tokens: int,
+        model: str = DEFAULT_MODEL,
+    ) -> None:
+        """
+        Add usage statistics from an API call.
+
+        Args:
+            input_tokens: Number of input tokens
+            output_tokens: Number of output tokens
+            model: Model name
+        """
+        cost, details = calculate_cost(input_tokens, output_tokens, model)
+
+        # Update totals
+        self.total_input_tokens += input_tokens
+        self.total_output_tokens += output_tokens
+        self.total_cost += cost
+
+        # Update per-model tracking
+        if model not in self.calls_by_model:
+            self.calls_by_model[model] = {
+                "calls": 0,
+                "input_tokens": 0,
+                "output_tokens": 0,
+                "cost": 0.0,
+            }
+
+        self.calls_by_model[model]["calls"] += 1
+        self.calls_by_model[model]["input_tokens"] += input_tokens
+        self.calls_by_model[model]["output_tokens"] += output_tokens
+        self.calls_by_model[model]["cost"] += cost
+
+    def add_embedding_tokens(self, tokens: int, model: str) -> None:
+        """
+        Add embedding token usage statistics.
+
+        Args:
+            tokens: Number of tokens processed for embedding
+            model: Embedding model name
+        """
+        # Calculate cost based on embedding model rates
+        # Default to 0.10 if model not found
+        cost_per_million = EMBEDDING_COSTS.get(model, 0.10)
+        cost = (tokens / 1_000_000) * cost_per_million
+
+        # Update totals
+        self.total_embedding_tokens += tokens
+        self.total_cost += cost
+
+        # Update per-model tracking
+        if model not in self.calls_by_model:
+            self.calls_by_model[model] = {
+                "calls": 0,
+                "embedding_tokens": 0,
+                "cost": 0.0,
+            }
+        else:
+            # Add embedding_tokens field if it doesn't exist
+            if "embedding_tokens" not in self.calls_by_model[model]:
+                self.calls_by_model[model]["embedding_tokens"] = 0
+
+        self.calls_by_model[model]["calls"] += 1
+        self.calls_by_model[model]["embedding_tokens"] = (
+            self.calls_by_model[model].get("embedding_tokens", 0) + tokens
+        )
+        self.calls_by_model[model]["cost"] += cost
+
+    def get_summary(self) -> TokenUsageMetrics:
+        """
+        Get a summary of token usage and costs.
+
+        Returns:
+            TokenUsageMetrics object with usage summary
+        """
+        models_converted: dict[str, TokenUsageMetrics.ModelUsage] = {}
+        for model_name, stats in self.calls_by_model.items():
+            models_converted[model_name] = TokenUsageMetrics.ModelUsage(
+                calls=int(stats.get("calls", 0)),
+                input_tokens=int(stats.get("input_tokens", 0)),
+                output_tokens=int(stats.get("output_tokens", 0)),
+                embedding_tokens=int(stats.get("embedding_tokens", 0)),
+                cost=float(stats.get("cost", 0.0)),
+            )
+
+        return TokenUsageMetrics(
+            total_calls=sum(m.calls for m in models_converted.values()),
+            total_input_tokens=self.total_input_tokens,
+            total_output_tokens=self.total_output_tokens,
+            total_embedding_tokens=self.total_embedding_tokens,
+            total_tokens=(
+                self.total_input_tokens +
+                self.total_output_tokens +
+                self.total_embedding_tokens
+            ),
+            total_cost_usd=self.total_cost,
+            models=models_converted,
+        )
+
+    def log_summary(self, level: int = logging.INFO) -> None:
+        """Log a summary of token usage and costs."""
+        summary = self.get_summary()
+
+        # Build log message
+        message = f"API Usage: {summary.total_calls} calls, "
+
+        # Add LLM token counts if any
+        if summary.total_input_tokens > 0 or summary.total_output_tokens > 0:  # noqa
+            message += (
+                f"LLM: {summary.total_input_tokens:,} input + "
+                f"{summary.total_output_tokens:,} output tokens, "
+            )
+
+        # Add embedding token counts if any
+        if summary.total_embedding_tokens > 0:
+            message += f"Embeddings: {summary.total_embedding_tokens:,} tokens, "  # noqa
+
+        # Add total cost
+        message += f"Total: ${summary.total_cost_usd:.4f} USD"
+
+        logger.log(level, message)

ragbandit_core-0.1.1.dist-info/METADATA

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: ragbandit-core
+Version: 0.1.1
+Summary: Core utilities for document processing, RAG configuration, querying, and evaluation.
+Author-email: Martim Chaves <martim@ragbandit.com>
+License: MIT
+Project-URL: Homepage, https://github.com/MartimChaves/ragbandit-core
+Project-URL: Documentation, https://github.com/MartimChaves/ragbandit-core#readme
+Project-URL: Source, https://github.com/MartimChaves/ragbandit-core
+Project-URL: Issues, https://github.com/MartimChaves/ragbandit-core/issues
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: llama-index>=0.12.52
+Requires-Dist: mistralai>=1.7.0
+Requires-Dist: ragas>=0.3.0
+Requires-Dist: cryptography>=44.0.2
+Dynamic: license-file
+
+# ragbandit-core
+
+Core utilities for:
+
+* Document ingestion & processing (OCR, chunking, embedding)
+* Building and running Retrieval-Augmented Generation (RAG) pipelines
+* Evaluating answers with automated metrics
+
+## Quick start
+
+```bash
+pip install ragbandit-core
+```
+
+```python
+from ragbandit.documents import (
+    DocumentPipeline,
+    ReferencesProcessor,
+    FootnoteProcessor,
+    MistralOCRDocument,
+    MistralEmbedder,
+    SemanticChunker
+)
+import os
+import logging
+from dotenv import load_dotenv
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+)
+
+MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")
+
+file_path = "./data/raw/[document_name].pdf"
+
+doc_pipeline = DocumentPipeline(
+    chunker=SemanticChunker(min_chunk_size=500, api_key=MISTRAL_API_KEY),
+    embedder=MistralEmbedder(model="mistral-embed", api_key=MISTRAL_API_KEY),  # noqa
+    ocr_processor=MistralOCRDocument(api_key=MISTRAL_API_KEY),
+    processors=[
+        ReferencesProcessor(api_key=MISTRAL_API_KEY),
+        FootnoteProcessor(api_key=MISTRAL_API_KEY),
+    ],
+)
+
+extended_response = doc_pipeline.process(file_path)
+
+```
+
+### Running Steps Manually
+
+For more control, you can run each pipeline step independently:
+
+```python
+from ragbandit.documents import (
+    DocumentPipeline,
+    ReferencesProcessor,
+    MistralOCRDocument,
+    MistralEmbedder,
+    SemanticChunker
+)
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")
+file_path = "./data/raw/[document_name].pdf"
+
+# Create pipeline with only the components you need
+pipeline = DocumentPipeline(
+    ocr_processor=MistralOCRDocument(api_key=MISTRAL_API_KEY),
+    processors=[ReferencesProcessor(api_key=MISTRAL_API_KEY)],
+    chunker=SemanticChunker(min_chunk_size=500, api_key=MISTRAL_API_KEY),
+    embedder=MistralEmbedder(model="mistral-embed", api_key=MISTRAL_API_KEY),
+)
+
+# Step 1: Run OCR
+ocr_result = pipeline.run_ocr(file_path)
+
+# Step 2: Run processors (optional)
+processing_results = pipeline.run_processors(ocr_result)
+final_doc = processing_results[-1]  # Get the last processor's output
+
+# Step 3: Chunk the document
+chunk_result = pipeline.run_chunker(final_doc)
+
+# Step 4: Embed chunks
+embedding_result = pipeline.run_embedder(chunk_result)
+```
+
+You can also create separate pipelines for different steps:
+
+```python
+# OCR-only pipeline
+ocr_pipeline = DocumentPipeline(
+    ocr_processor=MistralOCRDocument(api_key=MISTRAL_API_KEY)
+)
+ocr_result = ocr_pipeline.run_ocr(file_path)
+
+# Later, chunk with a different pipeline
+chunk_pipeline = DocumentPipeline(
+    chunker=SemanticChunker(min_chunk_size=500, api_key=MISTRAL_API_KEY)
+)
+chunks = chunk_pipeline.run_chunker(ocr_result)
+```
+
+## Package layout
+
+```
+ragbandit-core/
+├── src/ragbandit/
+│   ├── documents/   # document ingestion, OCR, chunking, 
+└── tests/
+```
+
+## License
+
+MIT

ragbandit_core-0.1.1.dist-info/RECORD

@@ -0,0 +1,38 @@
+ragbandit/__init__.py,sha256=W3cOQHgNtVtHh9o0l2myI7Nv8QLfW-5r06ddLJuhhyM,718
+ragbandit/schema.py,sha256=mGoqqluTCgZaAq4yQQxn4evDjr03gJRmEKT6Xn-F3wI,5859
+ragbandit/config/__init__.py,sha256=Xr1-QgP6oUhBR6I3OHP4dgCR6lh2LHcNqwC6AsA2bNI,52
+ragbandit/config/llms.py,sha256=HHB4BbzlgTy7kZxHJ77tpEPdZfhlOU8nlc4rYLw6v7w,816
+ragbandit/config/pricing.py,sha256=0PE4WTsdRUyG3eABUP9Zhme6QpHwGD1RBYOqqSRzD4A,1143
+ragbandit/documents/__init__.py,sha256=0r0zNIz_MzrzpKpLopUh0le8wCzI5xhi9CPjlelXz4Y,1254
+ragbandit/documents/document_pipeline.py,sha256=bDmOjhj8mIbMii3ZTLHA5blzPvdMmD_wTpx319gAjME,12328
+ragbandit/documents/chunkers/__init__.py,sha256=U2ptxUtW-e_OCl50kjg-YmKD2e1eGI6iPAWl8hG2W0s,464
+ragbandit/documents/chunkers/base_chunker.py,sha256=9sCEqn-uVesvYOh2aNbjoN9-mkkAQxml8-nuonr5zUk,6616
+ragbandit/documents/chunkers/fixed_size_chunker.py,sha256=--OQ5XVhATw4v_MEmfTJPkfUQ2fHXCJyYpWktWVi9JY,5764
+ragbandit/documents/chunkers/semantic_chunker.py,sha256=67I2TjytMSB_LWloGWhesOB7Hu4RlYBUsr9T8A9SD2I,7188
+ragbandit/documents/embedders/__init__.py,sha256=6do7BGP8rHCLvIoPIwcK5W751jl8spEfq2smgkoTK3o,418
+ragbandit/documents/embedders/base_embedder.py,sha256=Bdbmhvi82JxRCBtaY6ZFIbmmPkHriTqtZvvRs6k3dfg,2287
+ragbandit/documents/embedders/mistral_embedder.py,sha256=T0FPILc7PKIgWxV_lWQbqyP5_LElkuuGtDvn4-Ec6d8,4242
+ragbandit/documents/ocr/__init__.py,sha256=Dg3R2ClL1fDOA4a6hY8F7gHiR1mIgL0tNSbo88NPsGE,336
+ragbandit/documents/ocr/base_ocr.py,sha256=o3gTEg6WW88JDOAaKSKusqOGco4jQ9Q8nUl-zsStjMg,4375
+ragbandit/documents/ocr/mistral_ocr.py,sha256=074LRKDEIH4PYoRPrwP_3dUboVByefIqnLniqclz3Bg,5327
+ragbandit/documents/processors/__init__.py,sha256=ecWUqcNqSEuloXYczgfMPQwWb5vlehHM7s6jB3uEVwM,541
+ragbandit/documents/processors/base_processor.py,sha256=wVqgIjKDUhaSt8oyktTvY0b8jL9OYHQNvcD0VZcn-Wg,3128
+ragbandit/documents/processors/footnotes_processor.py,sha256=dRb6NXiRaXVMVKB7lijCofmZZUHqqFuyl7JunqEbqC8,13630
+ragbandit/documents/processors/references_processor.py,sha256=Fmg9MwBO9fB7sjrZl2q_ESTqTXNdzikVi1TLMJTAC3U,14520
+ragbandit/documents/utils/__init__.py,sha256=eS9AhbxRSJVnUU7JlHKNfJl3KNKCpLYTyl_Lo_SVaWU,244
+ragbandit/documents/utils/secure_file_handler.py,sha256=XGNd5dBfoqhYWo-jxHQkCWEidhurNI7MA-yR7KQHpF4,3098
+ragbandit/prompt_tools/__init__.py,sha256=PRnA0EF9yKSvErRxVs8esOJ4761UQjgtHvHdcjsaCB4,801
+ragbandit/prompt_tools/footnotes_processor_tools.py,sha256=_SgKN0wn98eBNlM7WGMAkiTEUnFXm9w5X5f7KKapnK8,6098
+ragbandit/prompt_tools/prompt_tool.py,sha256=lN8rEwWnuS3gW6c2l1IYadgRvBnCB0tiU5mkpeoxl3s,3824
+ragbandit/prompt_tools/references_processor_tools.py,sha256=0AqKRrdKiUKWsS0EAnrGlXVDPZM_oLdsr52WriWekNA,1063
+ragbandit/prompt_tools/semantic_chunker_tools.py,sha256=Y66-ttVhpyiHdq6He1D0vaaJthDc8pX45mDbn24ONrs,2088
+ragbandit/utils/__init__.py,sha256=nKj-69XL3HjzbMNOcJdMpsJt0J8N2KhGdQ19V_jQR1g,522
+ragbandit/utils/in_memory_log_handler.py,sha256=vMtCG-Wk9OwiCo2087nQovSIOQCu5ZWXg3lBf0hPEkk,1109
+ragbandit/utils/llm_utils.py,sha256=7motkdeez9D_eEBemY6Mw_tZZCCyvt886GEYHv9ddvs,7079
+ragbandit/utils/mistral_client.py,sha256=VkqFgquyjCmUllBjrHKqQnnmvU3yF0frvCSVIkHH-jQ,2195
+ragbandit/utils/token_usage_tracker.py,sha256=CMAuJolcdJ258CVMkpNVhZAnQIGC-jTnxYkOr2jvp0M,7196
+ragbandit_core-0.1.1.dist-info/licenses/LICENSE.md,sha256=rZBctov8cSToljMmrdApur6WqyMIrX0KjkMKDpqx9w8,1070
+ragbandit_core-0.1.1.dist-info/METADATA,sha256=FsGiCB_o8_vMQohVWsGN_o3gHzdM1usLA9Xw5zEi7bc,3924
+ragbandit_core-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ragbandit_core-0.1.1.dist-info/top_level.txt,sha256=UDjwZ4afIob8DIsuV6D08lU5bHCeN00grjXpzgDhsQ8,10
+ragbandit_core-0.1.1.dist-info/RECORD,,

ragbandit_core-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ragbandit_core-0.1.1.dist-info/licenses/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025 Martim Chaves
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

ragbandit_core-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+ragbandit