orizu 0.5.19 → 0.5.21

package/vendor/gepa-python/src/gepa/adapters/generic_rag_adapter/vector_stores/weaviate_store.py

@@ -0,0 +1,418 @@
+# Copyright (c) 2025 Lakshya A Agrawal and the GEPA contributors
+# https://github.com/gepa-ai/gepa
+
+from typing import Any
+
+from gepa.adapters.generic_rag_adapter.vector_store_interface import VectorStoreInterface
+
+
+class WeaviateVectorStore(VectorStoreInterface):
+    """
+    Weaviate implementation of the VectorStoreInterface.
+
+    Weaviate is a cloud-native, modular, real-time vector database
+    with powerful search capabilities including hybrid search.
+    Supports both Weaviate Cloud Services and self-hosted deployments.
+    """
+
+    def __init__(self, client, collection_name: str, embedding_function=None):
+        """
+        Initialize WeaviateVectorStore.
+
+        Args:
+            client: Weaviate client instance (WeaviateClient from weaviate-client)
+            collection_name: Name of the collection/class to use
+            embedding_function: Optional function to compute embeddings for queries
+        """
+        import importlib.util
+
+        if importlib.util.find_spec("weaviate") is None:
+            raise ImportError(
+                "Weaviate client is required for WeaviateVectorStore. Install with: pip install litellm weaviate-client"
+            )
+
+        import weaviate.classes as wvc
+
+        self.client = client
+        self.collection_name = collection_name
+        self.wvc = wvc
+        self.embedding_function = embedding_function
+
+        # Get the collection
+        try:
+            self.collection = self.client.collections.get(collection_name)
+        except Exception as e:
+            raise ValueError(
+                f"Collection '{collection_name}' not found. Please create the collection first. Error: {e!s}"
+            ) from e
+
+    def similarity_search(
+        self,
+        query: str,
+        k: int = 5,
+        filters: dict[str, Any] | None = None,
+    ) -> list[dict[str, Any]]:
+        """Search for documents similar to the query text using embeddings."""
+        if self.embedding_function is None:
+            raise ValueError("No embedding function provided for similarity search")
+
+        # Compute embeddings for the query
+        try:
+            query_vector = self.embedding_function(query)
+            if hasattr(query_vector, "tolist"):
+                query_vector = query_vector.tolist()
+        except Exception as e:
+            raise RuntimeError(f"Failed to compute embeddings for query: {e!s}") from e
+
+        # Use vector search with computed embeddings
+        return self.vector_search(query_vector, k, filters)
+
+    def vector_search(
+        self,
+        query_vector: list[float],
+        k: int = 5,
+        filters: dict[str, Any] | None = None,
+    ) -> list[dict[str, Any]]:
+        """Search using a pre-computed query vector."""
+        weaviate_filters = self._convert_filters(filters) if filters else None
+
+        try:
+            # Execute query
+            if weaviate_filters:
+                response = self.collection.query.near_vector(near_vector=query_vector, limit=k).where(weaviate_filters)
+            else:
+                response = self.collection.query.near_vector(near_vector=query_vector, limit=k)
+
+            # Handle GenerativeReturn object - access .objects attribute
+            if hasattr(response, "objects"):
+                results = response.objects
+            else:
+                results = response
+
+            return self._format_results(results)
+
+        except Exception as e:
+            raise RuntimeError(f"Weaviate vector search failed: {e!s}") from e
+
+    def hybrid_search(
+        self,
+        query: str,
+        k: int = 5,
+        alpha: float = 0.5,
+        filters: dict[str, Any] | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Hybrid semantic + keyword search using Weaviate's native hybrid search.
+
+        Args:
+            query: Text query to search for
+            k: Number of documents to return
+            alpha: Weight for semantic vs keyword search (0.0 = pure keyword, 1.0 = pure semantic)
+            filters: Optional metadata filters
+        """
+        weaviate_filters = self._convert_filters(filters) if filters else None
+
+        try:
+            results = self.collection.query.hybrid(
+                query=query,
+                alpha=alpha,
+                limit=k,
+                where=weaviate_filters,
+                return_metadata=self.wvc.query.MetadataQuery(score=True, explain_score=True),
+                return_properties=["content", "*"],
+            )
+
+            return self._format_results(results)
+
+        except Exception as e:
+            raise RuntimeError(f"Weaviate hybrid search failed: {e!s}") from e
+
+    def get_collection_info(self) -> dict[str, Any]:
+        """Get metadata about the Weaviate collection."""
+        try:
+            # Get collection configuration
+            config = self.collection.config.get()
+
+            # Count objects in collection
+            count_result = self.collection.aggregate.over_all(total_count=True)
+            total_count = count_result.total_count
+
+            # Try to determine vector dimensions
+            dimension = 0
+            if hasattr(config, "vector_config") and config.vector_config:
+                # For collections with vector config
+                if hasattr(config.vector_config, "vector_index_config"):
+                    vector_index = config.vector_index_config
+                    if hasattr(vector_index, "distance"):
+                        # This indicates vectors are configured
+                        # Try to get dimension from a sample object
+                        try:
+                            sample = self.collection.query.fetch_objects(limit=1, include_vector=True)
+                            if sample.objects and hasattr(sample.objects[0], "vector") and sample.objects[0].vector:
+                                # Handle both named vectors and default vector
+                                vector_data = sample.objects[0].vector
+                                if isinstance(vector_data, dict):
+                                    # Named vectors case
+                                    for _vector_name, vector_values in vector_data.items():
+                                        if vector_values:
+                                            dimension = len(vector_values)
+                                            break
+                                elif isinstance(vector_data, list):
+                                    # Default vector case
+                                    dimension = len(vector_data)
+                        except Exception:
+                            # If we can't determine dimension from sample, that's ok
+                            pass
+
+            # Determine if hybrid search is supported
+            supports_hybrid = True  # Weaviate generally supports hybrid search
+            try:
+                # Test if hybrid search works by doing a minimal query
+                self.collection.query.hybrid(query="test", limit=1)
+                supports_hybrid = True
+            except Exception:
+                supports_hybrid = False
+
+            return {
+                "name": self.collection_name,
+                "document_count": total_count,
+                "dimension": dimension,
+                "vector_store_type": "weaviate",
+                "supports_hybrid_search": supports_hybrid,
+                "vectorizer": getattr(config, "vectorizer_config", None),
+                "properties": [prop.name for prop in getattr(config, "properties", [])],
+            }
+
+        except Exception as e:
+            # Fallback info if detailed info fails
+            return {
+                "name": self.collection_name,
+                "document_count": 0,
+                "dimension": 0,
+                "vector_store_type": "weaviate",
+                "error": str(e),
+            }
+
+    def supports_hybrid_search(self) -> bool:
+        """Weaviate supports hybrid search."""
+        try:
+            # Test if hybrid search works
+            self.collection.query.hybrid(query="test", limit=1)
+            return True
+        except Exception:
+            return False
+
+    def supports_metadata_filtering(self) -> bool:
+        """Weaviate supports metadata filtering with where clauses."""
+        return True
+
+    def _convert_filters(self, filters: dict[str, Any]) -> Any:
+        """
+        Convert generic filters to Weaviate where clause format.
+
+        Generic format: {"key": "value", "key2": {"$gt": 5}}
+        Weaviate format uses Filter class
+        """
+        if not filters:
+            return None
+
+        try:
+            from weaviate.collections.classes.filters import Filter
+        except ImportError:
+            # Fallback if Filter class not available
+            return None
+
+        filter_conditions = []
+
+        for key, value in filters.items():
+            if isinstance(value, dict):
+                # Handle operator-based filters
+                for op, op_value in value.items():
+                    if op == "$eq" or op == "equal":
+                        filter_conditions.append(Filter.by_property(key).equal(op_value))
+                    elif op == "$ne" or op == "not_equal":
+                        filter_conditions.append(Filter.by_property(key).not_equal(op_value))
+                    elif op == "$gt" or op == "greater_than":
+                        filter_conditions.append(Filter.by_property(key).greater_than(op_value))
+                    elif op == "$gte" or op == "greater_equal":
+                        filter_conditions.append(Filter.by_property(key).greater_or_equal(op_value))
+                    elif op == "$lt" or op == "less_than":
+                        filter_conditions.append(Filter.by_property(key).less_than(op_value))
+                    elif op == "$lte" or op == "less_equal":
+                        filter_conditions.append(Filter.by_property(key).less_or_equal(op_value))
+                    elif op == "$in" or op == "contains_any":
+                        if isinstance(op_value, list):
+                            filter_conditions.append(Filter.by_property(key).contains_any(op_value))
+                    elif op == "$like" or op == "like":
+                        filter_conditions.append(Filter.by_property(key).like(op_value))
+            else:
+                # Simple equality filter
+                filter_conditions.append(Filter.by_property(key).equal(value))
+
+        # Combine all conditions with AND
+        if len(filter_conditions) == 1:
+            return filter_conditions[0]
+        elif len(filter_conditions) > 1:
+            combined_filter = filter_conditions[0]
+            for condition in filter_conditions[1:]:
+                combined_filter = combined_filter & condition
+            return combined_filter
+
+        return None
+
+    def _format_results(self, results) -> list[dict[str, Any]]:
+        """Convert Weaviate results to standardized format."""
+        documents = []
+
+        # Handle both GenerativeReturn objects and direct lists
+        if hasattr(results, "objects"):
+            objects_list = results.objects
+        else:
+            objects_list = results
+
+        if not objects_list:
+            return documents
+
+        for obj in objects_list:
+            # Get the content - try different property names
+            content = ""
+            properties = obj.properties
+
+            # Common content field names
+            content_fields = ["content", "text", "document", "body", "description"]
+            for field in content_fields:
+                if field in properties:
+                    content = properties[field]
+                    break
+
+            # If no content field found, use all text properties
+            if not content:
+                text_properties = []
+                for key, value in properties.items():
+                    if isinstance(value, str) and value.strip():
+                        text_properties.append(f"{key}: {value}")
+                content = " | ".join(text_properties)
+
+            # Extract metadata (all properties except content)
+            metadata = {}
+            for key, value in properties.items():
+                if key not in ["content", "text", "document", "body"] or not content:
+                    metadata[key] = value
+
+            # Add UUID as doc_id in metadata
+            metadata["doc_id"] = str(obj.uuid)
+
+            # Calculate similarity score from distance or use provided score
+            score = 0.0
+            if hasattr(obj.metadata, "score") and obj.metadata.score is not None:
+                score = float(obj.metadata.score)
+            elif hasattr(obj.metadata, "distance") and obj.metadata.distance is not None:
+                # Convert distance to similarity (assuming cosine distance)
+                # Weaviate cosine distance is between 0 and 2, similarity = 1 - (distance/2)
+                distance = float(obj.metadata.distance)
+                score = max(0.0, 1.0 - (distance / 2.0))
+
+            documents.append({"content": content, "metadata": metadata, "score": score})
+
+        return documents
+
+    @classmethod
+    def create_local(
+        cls,
+        host: str = "localhost",
+        port: int = 8080,
+        grpc_port: int = 50051,
+        collection_name: str = "Documents",
+        headers: dict[str, str] | None = None,
+    ) -> "WeaviateVectorStore":
+        """
+        Create a WeaviateVectorStore connected to local Weaviate instance.
+
+        Args:
+            host: Weaviate host
+            port: HTTP port
+            grpc_port: gRPC port
+            collection_name: Name of the collection
+            headers: Optional headers for authentication
+
+        Returns:
+            WeaviateVectorStore instance
+        """
+        try:
+            import weaviate
+        except ImportError as e:
+            raise ImportError("Weaviate client is required. Install with: pip install litellm weaviate-client") from e
+
+        client = weaviate.connect_to_local(host=host, port=port, grpc_port=grpc_port, headers=headers)
+
+        return cls(client, collection_name)
+
+    @classmethod
+    def create_cloud(
+        cls,
+        cluster_url: str,
+        auth_credentials,
+        collection_name: str = "Documents",
+        headers: dict[str, str] | None = None,
+    ) -> "WeaviateVectorStore":
+        """
+        Create a WeaviateVectorStore connected to Weaviate Cloud Services.
+
+        Args:
+            cluster_url: Weaviate cluster URL
+            auth_credentials: Authentication credentials (API key or other auth)
+            collection_name: Name of the collection
+            headers: Optional headers
+
+        Returns:
+            WeaviateVectorStore instance
+        """
+        try:
+            import weaviate
+        except ImportError as e:
+            raise ImportError("Weaviate client is required. Install with: pip install litellm weaviate-client") from e
+
+        client = weaviate.connect_to_weaviate_cloud(
+            cluster_url=cluster_url, auth_credentials=auth_credentials, headers=headers
+        )
+
+        return cls(client, collection_name)
+
+    @classmethod
+    def create_custom(
+        cls,
+        url: str,
+        auth_credentials=None,
+        collection_name: str = "Documents",
+        headers: dict[str, str] | None = None,
+        grpc_port: int | None = None,
+    ) -> "WeaviateVectorStore":
+        """
+        Create a WeaviateVectorStore with custom connection parameters.
+
+        Args:
+            url: Weaviate instance URL
+            auth_credentials: Authentication credentials
+            collection_name: Name of the collection
+            headers: Optional headers
+            grpc_port: Optional gRPC port
+
+        Returns:
+            WeaviateVectorStore instance
+        """
+        try:
+            import weaviate
+        except ImportError as e:
+            raise ImportError("Weaviate client is required. Install with: pip install litellm weaviate-client") from e
+
+        client = weaviate.connect_to_custom(
+            http_host=url,
+            http_port=443 if "https" in url else 80,
+            http_secure="https" in url,
+            grpc_port=grpc_port,
+            grpc_secure="https" in url,
+            auth_credentials=auth_credentials,
+            headers=headers,
+        )
+
+        return cls(client, collection_name)

package/vendor/gepa-python/src/gepa/adapters/langchain_adapter/__init__.py

@@ -0,0 +1,11 @@
+from gepa.adapters.langchain_adapter.langchain_adapter import (
+    LangChainAdapter,
+    last_message_text,
+    make_reflection_lm,
+)
+
+__all__ = [
+    "LangChainAdapter",
+    "last_message_text",
+    "make_reflection_lm",
+]

package/vendor/gepa-python/src/gepa/adapters/langchain_adapter/langchain_adapter.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+import logging
+import time
+from collections import Counter
+from collections.abc import Callable, Mapping, Sequence
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Any
+
+from langchain_core.language_models import BaseChatModel
+from langchain_core.messages import AIMessage, HumanMessage
+
+from gepa.core.adapter import EvaluationBatch, GEPAAdapter, ProposalFn
+
+logger = logging.getLogger(__name__)
+
+DataInst = Mapping[str, Any]
+RolloutState = dict[str, Any]
+RolloutFn = Callable[[dict[str, str], DataInst], RolloutState]
+EvalFn = Callable[[DataInst, RolloutState], tuple[float, str]]
+ReflectiveRecordFn = Callable[[DataInst, RolloutState, float, str], Mapping[str, Any]]
+ReflectionLM = Callable[[str], str]
+
+
+def make_reflection_lm(model: BaseChatModel | Mapping[str, Any] | str) -> ReflectionLM:
+    """Wrap a LangChain chat model into the `(prompt: str) -> str` callable GEPA expects.
+
+    `model` accepts either:
+      - a `BaseChatModel` instance,
+      - a `provider:model` string (passed to `init_chat_model`), or
+      - a kwargs mapping (passed via `init_chat_model(**model)`).
+    """
+    if not isinstance(model, BaseChatModel):
+        from langchain.chat_models import init_chat_model
+
+        model = init_chat_model(model) if isinstance(model, str) else init_chat_model(**dict(model))
+
+    def reflection_lm(prompt: str) -> str:
+        logger.debug("reflection prompt (%d chars):\n%s", len(prompt), prompt)
+        result = model.invoke([HumanMessage(content=prompt)])
+        content = result.content
+        if isinstance(content, list):
+            text = "".join(part.get("text", "") if isinstance(part, dict) else str(part) for part in content)
+        else:
+            text = str(content)
+        logger.debug("reflection response (%d chars):\n%s", len(text), text)
+        return text
+
+    return reflection_lm
+
+
+def last_message_text(state: RolloutState) -> str:
+    """Return the text content of the last message in a rollout state.
+
+    Works for both single-turn rollouts (`{"messages": [AIMessage(...)]}`) and
+    agent rollouts that follow LangGraph's standard state shape.
+    """
+    messages = state.get("messages") if isinstance(state, dict) else None
+    if not messages:
+        return ""
+    msg = messages[-1]
+    content = getattr(msg, "content", msg)
+    if isinstance(content, list):
+        return "".join(part.get("text", "") if isinstance(part, dict) else str(part) for part in content)
+    return str(content)
+
+
+def _default_reflective_record(data: DataInst, state: RolloutState, score: float, feedback: str) -> Mapping[str, Any]:
+    inputs = data.get("input", data)
+    return {
+        "Inputs": inputs,
+        "Generated Outputs": last_message_text(state),
+        "Feedback": feedback,
+    }
+
+
+def _truncate(text: str, limit: int = 800) -> str:
+    text = text.replace("\n", " ⏎ ")
+    if len(text) <= limit:
+        return text
+    return text[:limit] + f"... [+{len(text) - limit} chars]"
+
+
+class LangChainAdapter(GEPAAdapter):
+    """GEPA adapter for arbitrary LangChain rollouts.
+
+    Caller supplies:
+      - `rollout_fn(candidate, example) -> state dict`: any LangChain pipeline —
+        a single chat-model invocation, an agent built with `create_agent`, a
+        custom LangGraph graph, RAG, etc. Must return a state dict; for single-turn
+        cases return a dict with the messages key
+        `{"messages": messages + [AIMessage("llm response")]}`.
+        For agents, return the full agent state directly (e.g. `agent.invoke(...)`).
+      - `eval_fn(example, state) -> (score, feedback)`: scores the rollout state.
+        Use `last_message_text(state)` if you only need the final assistant text;
+        agents can inspect tool calls in `state["messages"]` directly.
+        Note: if `rollout_fn` raises, the adapter substitutes a stand-in state
+        of the form `{"messages": [AIMessage("ERROR: <type>: <msg>")], "error": e}`
+        and still calls `eval_fn` with it. Check `state.get("error")` to detect
+        rollout failures and score them appropriately (e.g. return 0.0 with a
+        feedback string explaining the failure to the reflection LM).
+      - `reflective_record_fn(example, state, score, feedback) -> mapping`
+        (optional): builds the per-example record passed to the reflection LM.
+        Defaults to `{"Inputs", "Generated Outputs", "Feedback"}` derived from
+        `example["input"]` and `last_message_text(state)`. Override to surface
+        tool-call traces, intermediate steps, or domain-specific context.
+      - `num_threads`: parallelism for `evaluate` (default 32).
+      - `custom_proposer`: optional `ProposalFn` to override GEPA's default
+        text-proposal behavior.
+      - `show_progress`: whether to render a tqdm progress bar during
+        `evaluate` (default True).
+
+    The candidate is a `dict[str, str]` of named text components; `rollout_fn`
+    decides how those components are wired into the call.
+    """
+
+    def __init__(
+        self,
+        rollout_fn: RolloutFn,
+        eval_fn: EvalFn,
+        num_threads: int = 32,
+        custom_proposer: ProposalFn | None = None,
+        reflective_record_fn: ReflectiveRecordFn = _default_reflective_record,
+        show_progress: bool = True,
+    ):
+        self.rollout_fn = rollout_fn
+        self.eval_fn = eval_fn
+        self.num_threads = num_threads
+        self.reflective_record_fn = reflective_record_fn
+        self.propose_new_texts = custom_proposer
+        self.show_progress = show_progress
+
+    def evaluate(
+        self,
+        batch: list[DataInst],
+        candidate: dict[str, str],
+        capture_traces: bool = False,
+    ) -> EvaluationBatch:
+        logger.info(
+            "evaluate: batch=%d capture_traces=%s components=%s",
+            len(batch),
+            capture_traces,
+            list(candidate.keys()),
+        )
+        for name, text in candidate.items():
+            logger.debug("candidate[%s]: %s", name, _truncate(text, limit=400))
+
+        outputs: list[Any] = [None] * len(batch)
+        scores: list[float] = [0.0] * len(batch)
+        trajectories: list[Any] | None = [None] * len(batch) if capture_traces else None
+
+        def run_one(idx: int, example: DataInst):
+            t0 = time.perf_counter()
+            error: Exception | None = None
+            try:
+                state: RolloutState = self.rollout_fn(candidate, example)
+                if not isinstance(state, dict):
+                    raise TypeError(
+                        f"rollout_fn must return a dict, got {type(state).__name__}. "
+                        f"For single-turn chat use {{'messages': [SystemMessage(...), HumanMessage(...), AIMessage(...)]}}; "
+                        f"for LangGraph agents return the agent state dict directly."
+                    )
+            except Exception as e:
+                state = {"messages": [AIMessage(content=f"ERROR: {type(e).__name__}: {e}")], "error": e}
+                error = e
+            elapsed_ms = (time.perf_counter() - t0) * 1000
+            score, feedback = self.eval_fn(example, state)
+            if error is not None:
+                input_preview = _truncate(str(example.get("input", example)), limit=120)
+                logger.warning(
+                    "example %d FAILED after %.0fms: %s: %s | input=%s",
+                    idx,
+                    elapsed_ms,
+                    type(error).__name__,
+                    error,
+                    input_preview,
+                    exc_info=logger.isEnabledFor(logging.DEBUG),
+                )
+            else:
+                logger.debug("example %d ok in %.0fms (score=%.2f)", idx, elapsed_ms, score)
+            return idx, state, score, feedback
+
+        start = time.perf_counter()
+        with ThreadPoolExecutor(max_workers=self.num_threads) as pool:
+            futures = [pool.submit(run_one, i, ex) for i, ex in enumerate(batch)]
+            iterator: Any = as_completed(futures)
+            if self.show_progress:
+                try:
+                    from tqdm.auto import tqdm
+
+                    iterator = tqdm(iterator, total=len(futures), desc="evaluate", leave=False)
+                except ImportError:
+                    pass
+
+            running_correct = 0
+            for f in iterator:
+                idx, state, score, feedback = f.result()
+                outputs[idx] = {"state": state, "response": last_message_text(state)}
+                scores[idx] = score
+                if trajectories is not None:
+                    trajectories[idx] = {
+                        "data": batch[idx],
+                        "state": state,
+                        "score": score,
+                        "feedback": feedback,
+                    }
+                if score == 1.0:
+                    running_correct += 1
+                if self.show_progress and hasattr(iterator, "set_postfix"):
+                    iterator.set_postfix(correct=running_correct, refresh=False)
+                logger.debug(
+                    "  example %d: score=%.3f feedback=%s",
+                    idx,
+                    score,
+                    _truncate(feedback, limit=200),
+                )
+
+        elapsed = time.perf_counter() - start
+        total = sum(scores)
+        mean = total / len(scores) if scores else 0.0
+
+        failure_counts: Counter[str] = Counter()
+        for o in outputs:
+            if isinstance(o, dict) and isinstance(o.get("state"), dict) and o["state"].get("error") is not None:
+                err_type = type(o["state"]["error"]).__name__
+                failure_counts[err_type] += 1
+        if failure_counts:
+            logger.warning(
+                "evaluate failures: %d/%d (by type: %s)",
+                sum(failure_counts.values()),
+                len(batch),
+                dict(failure_counts),
+            )
+
+        logger.info(
+            "evaluate done: mean=%.3f sum=%.3f n=%d in %.2fs",
+            mean,
+            total,
+            len(scores),
+            elapsed,
+        )
+        return EvaluationBatch(outputs=outputs, scores=scores, trajectories=trajectories)
+
+    def make_reflective_dataset(
+        self,
+        candidate: dict[str, str],
+        eval_batch: EvaluationBatch,
+        components_to_update: list[str],
+    ) -> Mapping[str, Sequence[Mapping[str, Any]]]:
+        records = [
+            self.reflective_record_fn(traj["data"], traj["state"], traj["score"], traj["feedback"])
+            for traj in (eval_batch.trajectories or [])
+        ]
+        if not records:
+            raise RuntimeError("No trajectories captured; cannot build reflective dataset.")
+        logger.info(
+            "reflective dataset: %d records for components=%s",
+            len(records),
+            components_to_update,
+        )
+        return dict.fromkeys(components_to_update, records)