empathy-framework 5.3.0__py3-none-any.whl → 5.4.0__py3-none-any.whl

empathy_llm_toolkit/agent_factory/adapters/haystack_adapter.py

@@ -1,298 +0,0 @@
-"""Haystack Adapter
-
-Creates RAG pipelines and document processing agents using deepset Haystack.
-Best for document QA, search, and NLP workflows.
-
-Requires: pip install haystack-ai
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import os
-from collections.abc import Callable
-from typing import Any
-
-from empathy_llm_toolkit.agent_factory.base import (
-    AgentCapability,
-    AgentConfig,
-    AgentRole,
-    BaseAdapter,
-    BaseAgent,
-    BaseWorkflow,
-    WorkflowConfig,
-)
-
-# Lazy import
-_haystack_available = None
-
-
-def _check_haystack():
-    """Check if Haystack is available."""
-    global _haystack_available
-    if _haystack_available is None:
-        try:
-            import haystack  # noqa: F401
-
-            _haystack_available = True
-        except ImportError:
-            _haystack_available = False
-    return _haystack_available
-
-
-class HaystackAgent(BaseAgent):
-    """Agent wrapping a Haystack Pipeline or Component."""
-
-    def __init__(self, config: AgentConfig, pipeline=None, generator=None):
-        super().__init__(config)
-        self._pipeline = pipeline
-        self._generator = generator
-
-    async def invoke(self, input_data: str | dict, context: dict | None = None) -> dict:
-        """Invoke the Haystack pipeline/generator."""
-        # Format query
-        if isinstance(input_data, str):
-            query = input_data
-        else:
-            query = input_data.get("query", input_data.get("input", str(input_data)))
-
-        try:
-            if self._pipeline:
-                # Run pipeline
-                result = self._pipeline.run({"query": query, **(context or {})})
-
-                # Extract answer
-                if "answers" in result:
-                    answers = result["answers"]
-                    output = answers[0].data if answers else "No answer found"
-                elif "replies" in result:
-                    output = result["replies"][0] if result["replies"] else "No reply"
-                else:
-                    output = str(result)
-
-            elif self._generator:
-                # Use generator directly
-                result = self._generator.run(prompt=query)
-                output = result.get("replies", [query])[0]
-
-            else:
-                output = f"[{self.name}] No pipeline configured"
-                result = {}
-
-            self._conversation_history.append({"role": "user", "content": query})
-            self._conversation_history.append({"role": "assistant", "content": output})
-
-            return {
-                "output": output,
-                "metadata": {
-                    "framework": "haystack",
-                    "model": self.model,
-                    "raw_result": result if isinstance(result, dict) else {},
-                },
-            }
-
-        except Exception as e:
-            return {"output": f"Error: {e}", "metadata": {"error": str(e)}}
-
-    async def stream(self, input_data: str | dict, context: dict | None = None):
-        """Haystack 2.0 supports streaming for some generators."""
-        # Most Haystack components don't stream; yield full result
-        result = await self.invoke(input_data, context)
-        yield result
-
-
-class HaystackWorkflow(BaseWorkflow):
-    """Workflow using Haystack Pipeline."""
-
-    def __init__(self, config: WorkflowConfig, agents: list[BaseAgent], pipeline=None):
-        super().__init__(config, agents)
-        self._pipeline = pipeline
-
-    async def run(self, input_data: str | dict, initial_state: dict | None = None) -> dict:
-        """Run the Haystack pipeline workflow."""
-        if isinstance(input_data, str):
-            query = input_data
-        else:
-            query = input_data.get("query", input_data.get("input", str(input_data)))
-
-        self._state = initial_state or {}
-
-        try:
-            if self._pipeline:
-                result = self._pipeline.run({"query": query, **self._state})
-
-                # Extract output
-                if "answers" in result:
-                    output = result["answers"][0].data if result["answers"] else ""
-                elif "replies" in result:
-                    output = result["replies"][0] if result["replies"] else ""
-                else:
-                    output = str(result)
-
-                self._state.update(result)
-
-                return {
-                    "output": output,
-                    "state": self._state,
-                    "metadata": {"framework": "haystack"},
-                }
-
-            # Fallback to sequential agent execution
-            return await self._run_sequential(input_data)
-
-        except Exception as e:
-            return {"output": f"Error: {e}", "error": str(e)}
-
-    async def _run_sequential(self, input_data: str | dict) -> dict:
-        """Fallback sequential execution."""
-        current = input_data
-        results = []
-        for agent in self.agents.values():
-            result = await agent.invoke(current)
-            results.append(result)
-            current = result.get("output", current)
-        return {"output": current, "results": results}
-
-    async def stream(self, input_data: str | dict, initial_state: dict | None = None):
-        """Stream workflow execution."""
-        result = await self.run(input_data, initial_state)
-        yield result
-
-
-class HaystackAdapter(BaseAdapter):
-    """Adapter for deepset Haystack framework."""
-
-    def __init__(self, provider: str = "anthropic", api_key: str | None = None):
-        self.provider = provider
-        self.api_key = api_key or os.getenv(
-            "ANTHROPIC_API_KEY" if provider == "anthropic" else "OPENAI_API_KEY",
-        )
-
-    @property
-    def framework_name(self) -> str:
-        return "haystack"
-
-    def is_available(self) -> bool:
-        return bool(_check_haystack())
-
-    def _get_generator(self, config: AgentConfig):
-        """Get Haystack generator based on provider."""
-        if not self.is_available():
-            raise ImportError("Haystack not installed. Run: pip install haystack-ai")
-
-        model_id = config.model_override or self.get_model_for_tier(
-            config.model_tier,
-            self.provider,
-        )
-
-        if self.provider == "anthropic":
-            from haystack_integrations.components.generators.anthropic import AnthropicChatGenerator
-
-            return AnthropicChatGenerator(
-                model=model_id,
-                api_key=self.api_key,
-                generation_kwargs={
-                    "temperature": config.temperature,
-                    "max_tokens": config.max_tokens,
-                },
-            )
-        if self.provider == "openai":
-            from haystack.components.generators import OpenAIGenerator
-
-            return OpenAIGenerator(
-                model=model_id,
-                api_key=self.api_key,
-                generation_kwargs={
-                    "temperature": config.temperature,
-                    "max_tokens": config.max_tokens,
-                },
-            )
-        raise ValueError(f"Unsupported provider for Haystack: {self.provider}")
-
-    def create_agent(self, config: AgentConfig) -> HaystackAgent:
-        """Create a Haystack agent."""
-        if not self.is_available():
-            raise ImportError("Haystack not installed")
-
-        # For RAG roles, create a full pipeline
-        if config.role in [AgentRole.RETRIEVER, AgentRole.ANSWERER, AgentRole.SUMMARIZER]:
-            if AgentCapability.RETRIEVAL in config.capabilities:
-                pipeline = self._create_rag_pipeline(config)
-                return HaystackAgent(config, pipeline=pipeline)
-
-        # For other roles, just use a generator
-        generator = self._get_generator(config)
-        return HaystackAgent(config, generator=generator)
-
-    def _create_rag_pipeline(self, config: AgentConfig):
-        """Create a RAG pipeline."""
-        from haystack import Pipeline
-        from haystack.components.builders import PromptBuilder
-
-        pipeline = Pipeline()
-
-        # Add prompt builder
-        template = (
-            config.system_prompt
-            or """
-        Answer the question based on the context.
-
-        Context: {{context}}
-        Question: {{query}}
-        Answer:
-        """
-        )
-        prompt_builder = PromptBuilder(template=template)
-        pipeline.add_component("prompt_builder", prompt_builder)
-
-        # Add generator
-        generator = self._get_generator(config)
-        pipeline.add_component("generator", generator)
-
-        # Connect components
-        pipeline.connect("prompt_builder", "generator")
-
-        return pipeline
-
-    def create_workflow(self, config: WorkflowConfig, agents: list[BaseAgent]) -> HaystackWorkflow:
-        """Create a Haystack Pipeline workflow."""
-        if not self.is_available():
-            raise ImportError("Haystack not installed")
-
-        from haystack import Pipeline
-
-        # Build a pipeline from agents
-        pipeline = Pipeline()
-
-        # For now, create a simple sequential pipeline
-        # More complex routing would require custom components
-
-        for _i, agent in enumerate(agents):
-            if hasattr(agent, "_generator") and agent._generator:
-                pipeline.add_component(f"agent_{agent.name}", agent._generator)
-
-        # Connect sequentially (simplified)
-        # Real implementation would need proper input/output mapping
-
-        return HaystackWorkflow(config, agents, pipeline=pipeline)
-
-    def create_tool(
-        self,
-        name: str,
-        description: str,
-        func: Callable,
-        args_schema: dict | None = None,
-    ) -> dict:
-        """Create a tool for Haystack (custom component would be needed)."""
-        return {"name": name, "description": description, "func": func, "args_schema": args_schema}
-
-    def create_document_store(self, store_type: str = "in_memory") -> Any:
-        """Create a Haystack document store."""
-        if not self.is_available():
-            raise ImportError("Haystack not installed")
-
-        if store_type == "in_memory":
-            from haystack.document_stores.in_memory import InMemoryDocumentStore
-
-            return InMemoryDocumentStore()
-        raise ValueError(f"Unsupported store type: {store_type}")

empathy_llm_toolkit/agent_factory/adapters/langchain_adapter.py

@@ -1,362 +0,0 @@
-"""LangChain Adapter
-
-Creates agents using LangChain's primitives while integrating
-with Empathy's cost optimization and pattern learning.
-
-Requires: pip install langchain langchain-anthropic langchain-openai
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import os
-from collections.abc import Callable
-from typing import Any
-
-from pydantic import SecretStr
-
-from empathy_llm_toolkit.agent_factory.base import (
-    AgentCapability,
-    AgentConfig,
-    BaseAdapter,
-    BaseAgent,
-    BaseWorkflow,
-    WorkflowConfig,
-)
-
-# Lazy imports for LangChain
-_langchain_available = None
-
-
-def _check_langchain():
-    """Check if LangChain is available."""
-    global _langchain_available
-    if _langchain_available is None:
-        try:
-            import langchain  # noqa: F401
-
-            _langchain_available = True
-        except ImportError:
-            _langchain_available = False
-    return _langchain_available
-
-
-class LangChainAgent(BaseAgent):
-    """Agent wrapping a LangChain chain or agent."""
-
-    def __init__(self, config: AgentConfig, chain=None, agent_executor=None):
-        super().__init__(config)
-        self._chain = chain
-        self._agent_executor = agent_executor
-        self._runnable = agent_executor or chain
-
-    async def invoke(self, input_data: str | dict, context: dict | None = None) -> dict:
-        """Invoke the LangChain agent/chain."""
-        if not self._runnable:
-            return {"output": "No LangChain runnable configured", "metadata": {}}
-
-        # Format input
-        invoke_input: dict[str, Any] = {}
-        if isinstance(input_data, str):
-            invoke_input = {"input": input_data}
-        else:
-            invoke_input = dict(input_data)
-
-        # Add context
-        if context:
-            invoke_input["context"] = context
-
-        # Add conversation history if memory enabled
-        if self.config.memory_enabled and self._conversation_history:
-            invoke_input["chat_history"] = self._conversation_history[-10:]
-
-        try:
-            # Use ainvoke for async
-            if hasattr(self._runnable, "ainvoke"):
-                result = await self._runnable.ainvoke(invoke_input)
-            else:
-                # Fallback to sync
-                result = self._runnable.invoke(invoke_input)
-
-            # Extract output
-            if isinstance(result, dict):
-                output = result.get("output", result.get("answer", str(result)))
-            else:
-                output = str(result)
-
-            # Track conversation
-            user_msg = invoke_input.get("input", str(input_data))
-            self._conversation_history.append({"role": "user", "content": user_msg})
-            self._conversation_history.append({"role": "assistant", "content": output})
-
-            return {
-                "output": output,
-                "metadata": {
-                    "model": self.model,
-                    "framework": "langchain",
-                    "raw_result": result if isinstance(result, dict) else None,
-                },
-            }
-
-        except Exception as e:
-            return {
-                "output": f"Error: {e!s}",
-                "metadata": {"error": str(e), "framework": "langchain"},
-            }
-
-    async def stream(self, input_data: str | dict, context: dict | None = None):
-        """Stream LangChain response."""
-        if not self._runnable:
-            yield {"output": "No LangChain runnable configured", "metadata": {}}
-            return
-
-        # Format input
-        if isinstance(input_data, str):
-            invoke_input = {"input": input_data}
-        else:
-            invoke_input = input_data
-
-        try:
-            if hasattr(self._runnable, "astream"):
-                async for chunk in self._runnable.astream(invoke_input):
-                    if isinstance(chunk, dict):
-                        yield chunk
-                    else:
-                        yield {"chunk": str(chunk)}
-            else:
-                # Fallback to non-streaming
-                result = await self.invoke(input_data, context)
-                yield result
-        except Exception as e:
-            yield {"error": str(e)}
-
-
-class LangChainWorkflow(BaseWorkflow):
-    """Workflow using LangChain's SequentialChain or custom routing."""
-
-    def __init__(self, config: WorkflowConfig, agents: list[BaseAgent], chain=None):
-        super().__init__(config, agents)
-        self._chain = chain
-
-    async def run(self, input_data: str | dict, initial_state: dict | None = None) -> dict:
-        """Run the LangChain workflow."""
-        self._state = initial_state or {}
-
-        if self._chain:
-            # Use the composed chain
-            try:
-                if hasattr(self._chain, "ainvoke"):
-                    result = await self._chain.ainvoke(input_data)
-                else:
-                    result = self._chain.invoke(input_data)
-
-                output = (
-                    result.get("output", str(result)) if isinstance(result, dict) else str(result)
-                )
-                return {"output": output, "results": [result], "state": self._state}
-            except Exception as e:
-                return {"output": f"Error: {e}", "error": str(e)}
-        else:
-            # Fallback to sequential agent execution
-            results = []
-            current_input = input_data
-
-            for agent in self.agents.values():
-                result = await agent.invoke(current_input, {"state": self._state})
-                result["agent"] = agent.name
-                results.append(result)
-                current_input = result["output"]
-
-            return {
-                "output": results[-1]["output"] if results else "",
-                "results": results,
-                "state": self._state,
-            }
-
-    async def stream(self, input_data: str | dict, initial_state: dict | None = None):
-        """Stream workflow execution."""
-        for agent in self.agents.values():
-            yield {"event": "agent_start", "agent": agent.name}
-            stream_gen = agent.stream(input_data)
-            async for chunk in stream_gen:  # type: ignore[attr-defined]
-                yield {"event": "chunk", "agent": agent.name, "data": chunk}
-            yield {"event": "agent_end", "agent": agent.name}
-
-
-class LangChainAdapter(BaseAdapter):
-    """Adapter for LangChain framework."""
-
-    def __init__(self, provider: str = "anthropic", api_key: str | None = None):
-        """Initialize LangChain adapter.
-
-        Args:
-            provider: LLM provider (anthropic, openai)
-            api_key: API key (uses env var if not provided)
-
-        """
-        self.provider = provider
-        self.api_key = api_key or os.getenv(
-            "ANTHROPIC_API_KEY" if provider == "anthropic" else "OPENAI_API_KEY",
-        )
-
-    @property
-    def framework_name(self) -> str:
-        return "langchain"
-
-    def is_available(self) -> bool:
-        """Check if LangChain is installed."""
-        return bool(_check_langchain())
-
-    def _get_llm(self, config: AgentConfig):
-        """Get LangChain LLM based on config."""
-        if not self.is_available():
-            raise ImportError(
-                "LangChain not installed. Run: pip install langchain langchain-anthropic",
-            )
-
-        model_id = config.model_override or self.get_model_for_tier(
-            config.model_tier,
-            self.provider,
-        )
-
-        if self.provider == "anthropic":
-            from langchain_anthropic import ChatAnthropic
-
-            # LangChain API varies between versions - use type: ignore for flexibility
-            # ChatAnthropic requires api_key as SecretStr (not None)
-            if not self.api_key:
-                raise ValueError("API key required for Anthropic provider")
-            return ChatAnthropic(  # type: ignore[call-arg]
-                model=model_id,
-                api_key=SecretStr(self.api_key),
-                temperature=config.temperature,
-                max_tokens_to_sample=config.max_tokens,
-            )
-        if self.provider == "openai":
-            from langchain_openai import ChatOpenAI
-
-            return ChatOpenAI(
-                model=model_id,
-                api_key=self.api_key,
-                temperature=config.temperature,
-                max_tokens=config.max_tokens,
-            )
-        raise ValueError(f"Unsupported provider for LangChain: {self.provider}")
-
-    def create_agent(self, config: AgentConfig) -> LangChainAgent:
-        """Create a LangChain-based agent."""
-        if not self.is_available():
-            raise ImportError("LangChain not installed")
-
-        # Import from langchain or langgraph depending on version
-        # In langchain 1.x, these moved to different locations
-        try:
-            # Try langchain 1.x imports first
-            from langchain.agents import create_tool_calling_agent  # type: ignore[attr-defined]
-            from langchain.agents.agent import AgentExecutor
-        except (ImportError, AttributeError):
-            # Fall back to langgraph for newer versions
-            AgentExecutor: Any = None  # type: ignore[no-redef]
-            try:
-                from langgraph.prebuilt import create_react_agent
-
-                create_tool_calling_agent: Any = create_react_agent  # type: ignore[no-redef]
-            except ImportError:
-                create_tool_calling_agent = None
-        from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-
-        llm = self._get_llm(config)
-
-        # Build system prompt
-        system_prompt = config.system_prompt or self._default_system_prompt(config)
-
-        # Create prompt template
-        prompt = ChatPromptTemplate.from_messages(
-            [
-                ("system", system_prompt),
-                MessagesPlaceholder(variable_name="chat_history", optional=True),
-                ("human", "{input}"),
-                MessagesPlaceholder(variable_name="agent_scratchpad", optional=True),
-            ],
-        )
-
-        # Convert tools to LangChain format
-        lc_tools = []
-        for tool in config.tools:
-            lc_tool = self._convert_tool(tool)
-            if lc_tool:
-                lc_tools.append(lc_tool)
-
-        if lc_tools and AgentCapability.TOOL_USE in config.capabilities:
-            # Create tool-calling agent
-            agent = create_tool_calling_agent(llm, lc_tools, prompt)
-            executor = AgentExecutor(agent=agent, tools=lc_tools, verbose=False)
-            return LangChainAgent(config, agent_executor=executor)
-        # Create simple chain (prompt | llm)
-        chain = prompt | llm
-        return LangChainAgent(config, chain=chain)
-
-    def create_workflow(self, config: WorkflowConfig, agents: list[BaseAgent]) -> LangChainWorkflow:
-        """Create a LangChain workflow."""
-        # For sequential mode, we can compose chains
-        # For more complex modes, just wrap the agents
-        return LangChainWorkflow(config, agents)
-
-    def create_tool(
-        self,
-        name: str,
-        description: str,
-        func: Callable,
-        args_schema: dict | None = None,
-    ) -> Any:
-        """Create a LangChain tool."""
-        if not self.is_available():
-            return super().create_tool(name, description, func, args_schema)
-
-        from langchain_core.tools import StructuredTool
-
-        return StructuredTool.from_function(func=func, name=name, description=description)
-
-    def _convert_tool(self, tool: Any) -> Any:
-        """Convert a tool to LangChain format."""
-        if not self.is_available():
-            return None
-
-        # If already a LangChain tool, return as-is
-        try:
-            from langchain_core.tools import BaseTool
-
-            if isinstance(tool, BaseTool):
-                return tool
-        except ImportError:
-            pass
-
-        # If dict, convert to StructuredTool
-        if isinstance(tool, dict):
-            return self.create_tool(
-                name=tool.get("name", "tool"),
-                description=tool.get("description", ""),
-                func=tool.get("func", lambda x: x),
-                args_schema=tool.get("args_schema"),
-            )
-
-        return None
-
-    def _default_system_prompt(self, config: AgentConfig) -> str:
-        """Generate default system prompt based on role."""
-        role_prompts = {
-            "researcher": "You are a thorough researcher. Gather information and cite sources.",
-            "writer": "You are a skilled writer. Create clear, engaging content.",
-            "reviewer": "You are a critical reviewer. Provide constructive feedback.",
-            "editor": "You are an experienced editor. Refine and improve content.",
-            "debugger": "You are an expert debugger. Analyze code issues systematically.",
-            "security": "You are a security analyst. Identify vulnerabilities and risks.",
-            "coordinator": "You coordinate a team of agents. Delegate and synthesize results.",
-        }
-
-        base = role_prompts.get(config.role.value, f"You are a helpful {config.role.value} agent.")
-
-        if config.description:
-            base = f"{base}\n\n{config.description}"
-
-        return base