attune-ai 2.0.0__py3-none-any.whl

attune_llm/agent_factory/adapters/langgraph_adapter.py

@@ -0,0 +1,333 @@
+"""LangGraph Adapter
+
+Creates stateful multi-agent workflows using LangGraph's graph primitives.
+Best for complex workflows with cycles, conditional routing, and state management.
+
+Requires: pip install langgraph langchain-anthropic
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import asyncio
+import os
+from collections.abc import Callable
+from typing import Any
+
+from pydantic import SecretStr
+
+from attune_llm.agent_factory.base import (
+    AgentConfig,
+    BaseAdapter,
+    BaseAgent,
+    BaseWorkflow,
+    WorkflowConfig,
+)
+
+# Lazy imports
+_langgraph_available = None
+
+
+def _check_langgraph():
+    """Check if LangGraph is available."""
+    global _langgraph_available
+    if _langgraph_available is None:
+        try:
+            import langgraph  # noqa: F401
+
+            _langgraph_available = True
+        except ImportError:
+            _langgraph_available = False
+    return _langgraph_available
+
+
+class LangGraphAgent(BaseAgent):
+    """Agent wrapping a LangGraph node/runnable."""
+
+    def __init__(self, config: AgentConfig, runnable=None, node_func=None):
+        super().__init__(config)
+        self._runnable = runnable
+        self._node_func = node_func
+
+    async def invoke(self, input_data: str | dict, context: dict | None = None) -> dict:
+        """Invoke the agent."""
+        # Format as state dict
+        if isinstance(input_data, str):
+            state = {"messages": [{"role": "user", "content": input_data}]}
+        elif isinstance(input_data, dict):
+            state = input_data.copy()
+        else:
+            state = {"input": input_data}
+
+        # Merge context into state
+        if context:
+            state.update(context)
+
+        try:
+            if self._runnable:
+                if hasattr(self._runnable, "ainvoke"):
+                    result = await self._runnable.ainvoke(state)
+                else:
+                    result = self._runnable.invoke(state)
+            elif self._node_func:
+                result = (
+                    await self._node_func(state)
+                    if asyncio.iscoroutinefunction(self._node_func)
+                    else self._node_func(state)
+                )
+            else:
+                result = {"output": f"[{self.name}] No runnable configured"}
+
+            # Extract output from messages or output key
+            if isinstance(result, dict):
+                if result.get("messages"):
+                    output = result["messages"][-1].get("content", str(result["messages"][-1]))
+                else:
+                    output = result.get("output", str(result))
+            else:
+                output = str(result)
+
+            self._conversation_history.append({"role": "user", "content": str(input_data)})
+            self._conversation_history.append({"role": "assistant", "content": output})
+
+            return {
+                "output": output,
+                "state": result if isinstance(result, dict) else {},
+                "metadata": {"framework": "langgraph", "model": self.model},
+            }
+
+        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):
+        """Stream agent response."""
+        if self._runnable and hasattr(self._runnable, "astream"):
+            state = (
+                {"messages": [{"role": "user", "content": input_data}]}
+                if isinstance(input_data, str)
+                else input_data
+            )
+            async for chunk in self._runnable.astream(state):
+                yield chunk
+        else:
+            result = await self.invoke(input_data, context)
+            yield result
+
+
+class LangGraphWorkflow(BaseWorkflow):
+    """Workflow using LangGraph's StateGraph."""
+
+    def __init__(self, config: WorkflowConfig, agents: list[BaseAgent], graph=None):
+        super().__init__(config, agents)
+        self._graph = graph
+        self._compiled = None
+
+    def _compile_graph(self):
+        """Compile the graph if not already compiled."""
+        if self._compiled is None and self._graph:
+            self._compiled = self._graph.compile()
+        return self._compiled
+
+    async def run(self, input_data: str | dict, initial_state: dict | None = None) -> dict:
+        """Run the LangGraph workflow."""
+        compiled = self._compile_graph()
+
+        # Prepare input state
+        if isinstance(input_data, str):
+            state = {"messages": [{"role": "user", "content": input_data}]}
+        else:
+            state = input_data.copy()
+
+        if initial_state:
+            state.update(initial_state)
+
+        self._state = state
+
+        try:
+            if compiled:
+                if hasattr(compiled, "ainvoke"):
+                    result = await compiled.ainvoke(state)
+                else:
+                    result = compiled.invoke(state)
+            else:
+                # Fallback to sequential
+                result = await self._run_sequential(input_data)
+
+            # Extract output
+            if isinstance(result, dict):
+                if result.get("messages"):
+                    output = result["messages"][-1].get("content", "")
+                else:
+                    output = result.get("output", str(result))
+                self._state = result
+            else:
+                output = str(result)
+
+            return {"output": output, "state": self._state, "metadata": {"framework": "langgraph"}}
+
+        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
+        for agent in self.agents.values():
+            result = await agent.invoke(current)
+            current = result.get("output", result)
+        return {"output": current, "messages": []}
+
+    async def stream(self, input_data: str | dict, initial_state: dict | None = None):
+        """Stream workflow execution."""
+        compiled = self._compile_graph()
+
+        if isinstance(input_data, str):
+            state = {"messages": [{"role": "user", "content": input_data}]}
+        else:
+            state = input_data.copy()
+
+        if compiled and hasattr(compiled, "astream"):
+            async for event in compiled.astream(state):
+                yield event
+        else:
+            result = await self.run(input_data, initial_state)
+            yield result
+
+
+class LangGraphAdapter(BaseAdapter):
+    """Adapter for LangGraph 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 "langgraph"
+
+    def is_available(self) -> bool:
+        return bool(_check_langgraph())
+
+    def _get_llm(self, config: AgentConfig) -> Any:
+        """Get LangChain LLM for use in LangGraph."""
+        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,  # Anthropic uses max_tokens_to_sample
+            )
+        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: {self.provider}")
+
+    def create_agent(self, config: AgentConfig) -> LangGraphAgent:
+        """Create a LangGraph-compatible agent."""
+        if not self.is_available():
+            raise ImportError("LangGraph not installed. Run: pip install langgraph")
+
+        from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+
+        llm = self._get_llm(config)
+
+        # Build prompt
+        system = config.system_prompt or f"You are a {config.role.value} agent."
+        prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", system),
+                MessagesPlaceholder(variable_name="messages"),
+            ],
+        )
+
+        # Create runnable
+        chain = prompt | llm
+
+        return LangGraphAgent(config, runnable=chain)
+
+    def create_workflow(self, config: WorkflowConfig, agents: list[BaseAgent]) -> LangGraphWorkflow:
+        """Create a LangGraph StateGraph workflow."""
+        if not self.is_available():
+            raise ImportError("LangGraph not installed")
+
+        from langgraph.graph import END, StateGraph
+        from typing_extensions import TypedDict
+
+        # Define state schema
+        class WorkflowState(TypedDict):
+            messages: list
+            current_agent: str
+            iteration: int
+
+        # Build graph
+        graph = StateGraph(WorkflowState)
+
+        # Add agent nodes
+        for agent in agents:
+
+            async def agent_node(state, a=agent):
+                result = await a.invoke(state)
+                messages = state.get("messages", [])
+                messages.append({"role": "assistant", "content": result["output"], "agent": a.name})
+                return {"messages": messages, "current_agent": a.name}
+
+            graph.add_node(agent.name, agent_node)
+
+        # Build edges based on mode
+        agent_names = [a.name for a in agents]
+
+        if config.mode == "sequential":
+            # Linear chain: agent1 -> agent2 -> ... -> END
+            graph.set_entry_point(agent_names[0])
+            for i in range(len(agent_names) - 1):
+                graph.add_edge(agent_names[i], agent_names[i + 1])
+            graph.add_edge(agent_names[-1], END)
+
+        elif config.mode == "parallel":
+            # All agents run, then merge at END
+            # (LangGraph doesn't natively support parallel, so we use fan-out)
+            graph.set_entry_point(agent_names[0])
+            for name in agent_names:
+                graph.add_edge(name, END)
+
+        else:
+            # Default: sequential
+            graph.set_entry_point(agent_names[0])
+            for i in range(len(agent_names) - 1):
+                graph.add_edge(agent_names[i], agent_names[i + 1])
+            graph.add_edge(agent_names[-1], END)
+
+        return LangGraphWorkflow(config, agents, graph=graph)
+
+    def create_tool(
+        self,
+        name: str,
+        description: str,
+        func: Callable,
+        args_schema: dict | None = None,
+    ) -> Any:
+        """Create a tool (same as LangChain)."""
+        if not self.is_available():
+            return {"name": name, "description": description, "func": func}
+
+        from langchain_core.tools import StructuredTool
+
+        return StructuredTool.from_function(func=func, name=name, description=description)

attune_llm/agent_factory/adapters/native.py

@@ -0,0 +1,228 @@
+"""Native Empathy Adapter
+
+Creates agents using Empathy's built-in EmpathyLLM system.
+No external dependencies required.
+
+Features:
+- Full EmpathyLLM integration (levels 1-5)
+- ModelRouter for cost optimization
+- Pattern learning and memory
+- Cost tracking
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import asyncio
+import os
+from collections.abc import Callable
+from typing import Any
+
+from attune_llm.agent_factory.base import (
+    AgentConfig,
+    BaseAdapter,
+    BaseAgent,
+    BaseWorkflow,
+    WorkflowConfig,
+)
+
+
+class NativeAgent(BaseAgent):
+    """Agent using Empathy's native EmpathyLLM."""
+
+    def __init__(self, config: AgentConfig, llm=None):
+        super().__init__(config)
+        self._llm = llm
+        self._tools = {tool["name"]: tool for tool in config.tools if isinstance(tool, dict)}
+
+    async def invoke(self, input_data: str | dict, context: dict | None = None) -> dict:
+        """Invoke the agent."""
+        # Format input
+        if isinstance(input_data, str):
+            user_input = input_data
+        else:
+            user_input = input_data.get("input", input_data.get("query", str(input_data)))
+
+        # Handle empty input
+        if not user_input or not user_input.strip():
+            return {
+                "output": "",
+                "metadata": {
+                    "level": self.config.empathy_level,
+                    "model": self.model,
+                    "skipped": True,
+                },
+            }
+
+        # Build context
+        ctx = context or {}
+        ctx["agent_name"] = self.name
+        ctx["agent_role"] = self.role.value
+
+        # Add conversation history
+        if self._conversation_history:
+            ctx["conversation_history"] = self._conversation_history[-10:]
+
+        # Use EmpathyLLM if available
+        if self._llm:
+            response = await self._llm.interact(
+                user_id=f"agent_{self.name}",
+                user_input=user_input,
+                context=ctx,
+            )
+            output = response.get("response", "")
+            metadata = {
+                "level": response.get("level", self.config.empathy_level),
+                "model": response.get("model", self.model),
+                "patterns_used": response.get("patterns_used", []),
+            }
+        else:
+            # Fallback to simple response
+            output = f"[{self.name}] I would process: {user_input}"
+            metadata = {"level": self.config.empathy_level, "model": self.model}
+
+        # Track conversation
+        self._conversation_history.append({"role": "user", "content": user_input})
+        self._conversation_history.append({"role": "assistant", "content": output})
+
+        return {"output": output, "metadata": metadata}
+
+    async def stream(self, input_data: str | dict, context: dict | None = None):
+        """Stream agent response."""
+        # Native adapter doesn't support streaming yet, yield full response
+        result = await self.invoke(input_data, context)
+        yield result
+
+
+class NativeWorkflow(BaseWorkflow):
+    """Workflow using sequential/parallel agent execution."""
+
+    async def run(self, input_data: str | dict, initial_state: dict | None = None) -> dict:
+        """Run the workflow."""
+        self._state = initial_state or {}
+        self._state["input"] = input_data
+
+        mode = self.config.mode
+        results = []
+
+        if mode == "sequential":
+            results = await self._run_sequential(input_data)
+        elif mode == "parallel":
+            results = await self._run_parallel(input_data)
+        else:
+            results = await self._run_sequential(input_data)
+
+        self._state["results"] = results
+        self._state["final_output"] = results[-1]["output"] if results else ""
+
+        return {
+            "output": self._state["final_output"],
+            "results": results,
+            "state": self._state,
+            "agents_invoked": [r.get("agent") for r in results],
+        }
+
+    async def _run_sequential(self, input_data: str | dict) -> list[dict]:
+        """Run agents sequentially, passing output to next."""
+        results: list[dict] = []
+        current_input = input_data
+
+        for agent in self.agents.values():
+            context = {"previous_results": results, "state": self._state}
+            result = await agent.invoke(current_input, context)
+            result["agent"] = agent.name
+            results.append(result)
+            current_input = result["output"]
+
+        return results
+
+    async def _run_parallel(self, input_data: str | dict) -> list:
+        """Run all agents in parallel."""
+        tasks = []
+        for agent in self.agents.values():
+            context = {"state": self._state}
+            tasks.append(agent.invoke(input_data, context))
+
+        results = await asyncio.gather(*tasks)
+
+        # Add agent names
+        for _i, (agent_name, result) in enumerate(zip(self.agents.keys(), results, strict=False)):
+            result["agent"] = agent_name
+
+        return list(results)
+
+    async def stream(self, input_data: str | dict, initial_state: dict | None = None):
+        """Stream workflow execution."""
+        self._state = initial_state or {}
+        self._state["input"] = input_data
+
+        for agent in self.agents.values():
+            context = {"state": self._state}
+            yield {"event": "agent_start", "agent": agent.name}
+
+            # agent.stream returns an async generator
+            stream_gen = agent.stream(input_data, context)
+            async for chunk in stream_gen:  # type: ignore[attr-defined]
+                yield {"event": "agent_output", "agent": agent.name, "data": chunk}
+
+            yield {"event": "agent_end", "agent": agent.name}
+
+
+class NativeAdapter(BaseAdapter):
+    """Adapter for Empathy's native agent system."""
+
+    def __init__(self, provider: str = "anthropic", api_key: str | None = None):
+        """Initialize native adapter.
+
+        Args:
+            provider: LLM provider (anthropic, openai, local)
+            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",
+        )
+        self._llm: Any = None  # EmpathyLLM instance or None
+
+    @property
+    def framework_name(self) -> str:
+        return "native"
+
+    def is_available(self) -> bool:
+        """Native is always available."""
+        return True
+
+    def _get_llm(self, config: AgentConfig) -> Any:
+        """Get or create EmpathyLLM instance."""
+        if self._llm is None and self.api_key:
+            try:
+                from attune_llm.core import EmpathyLLM
+
+                self._llm = EmpathyLLM(
+                    provider=self.provider,
+                    api_key=self.api_key,
+                    target_level=config.empathy_level,
+                )
+            except ImportError:
+                pass
+        return self._llm
+
+    def create_agent(self, config: AgentConfig) -> NativeAgent:
+        """Create a native Empathy agent."""
+        llm = self._get_llm(config)
+        return NativeAgent(config, llm=llm)
+
+    def create_workflow(self, config: WorkflowConfig, agents: list[BaseAgent]) -> NativeWorkflow:
+        """Create a native workflow."""
+        return NativeWorkflow(config, agents)
+
+    def create_tool(
+        self,
+        name: str,
+        description: str,
+        func: Callable,
+        args_schema: dict | None = None,
+    ) -> dict:
+        """Create a tool dict for native agents."""
+        return {"name": name, "description": description, "func": func, "args_schema": args_schema}