@sylix/coworker 2.0.10 → 2.0.12

package/dist/skills/defaults/llm-application/langchain.md

@@ -0,0 +1,259 @@
+---
+name: langchain-architecture
+description: Design LLM applications using LangChain 1.x and LangGraph for agents, memory, and tool integration. Use when building LangChain applications, implementing AI agents, or creating complex LLM workflows.
+---
+
+# LangChain & LangGraph Architecture
+
+Master modern LangChain 1.x and LangGraph for building sophisticated LLM applications with agents, state management, memory, and tool integration.
+
+## When to Use This Skill
+
+- Building autonomous AI agents with tool access
+- Implementing complex multi-step LLM workflows
+- Managing conversation memory and state
+- Integrating LLMs with external data sources and APIs
+- Creating modular, reusable LLM application components
+- Implementing document processing pipelines
+- Building production-grade LLM applications
+
+## Package Structure (LangChain 1.x)
+
+```
+langchain (1.2.x)         # High-level orchestration
+langchain-core (1.2.x)    # Core abstractions
+langchain-community       # Third-party integrations
+langgraph                 # Agent orchestration
+langchain-openai          # OpenAI integrations
+langchain-anthropic       # Anthropic/Claude integrations
+```
+
+## Core Concepts
+
+### 1. LangGraph Agents
+
+LangGraph is the standard for building agents:
+
+**Key Features:**
+- **StateGraph**: Explicit state management with typed state
+- **Durable Execution**: Agents persist through failures
+- **Human-in-the-Loop**: Inspect and modify state at any point
+- **Memory**: Short-term and long-term memory across sessions
+- **Checkpointing**: Save and resume agent state
+
+**Agent Patterns:**
+- **ReAct**: Reasoning + Acting with `create_react_agent`
+- **Plan-and-Execute**: Separate planning and execution nodes
+- **Multi-Agent**: Supervisor routing between specialized agents
+- **Tool-Calling**: Structured tool invocation with Pydantic schemas
+
+### 2. State Management
+
+```python
+from typing import Annotated, TypedDict
+from langgraph.graph import MessagesState
+
+class AgentState(MessagesState):
+    """Extends MessagesState with custom fields."""
+    context: Annotated[list, "retrieved documents"]
+
+class CustomState(TypedDict):
+    messages: Annotated[list, "conversation history"]
+    context: Annotated[dict, "retrieved context"]
+    current_step: str
+    results: list
+```
+
+### 3. Memory Systems
+
+- **ConversationBufferMemory**: Stores all messages
+- **ConversationSummaryMemory**: Summarizes older messages
+- **ConversationTokenBufferMemory**: Token-based windowing
+- **VectorStoreRetrieverMemory**: Semantic similarity retrieval
+- **LangGraph Checkpointers**: Persistent state across sessions
+
+## Quick Start
+
+### Modern ReAct Agent with LangGraph
+
+```python
+from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_anthropic import ChatAnthropic
+from langchain_core.tools import tool
+
+llm = ChatAnthropic(model="claude-sonnet-4-6", temperature=0)
+
+@tool
+def search_database(query: str) -> str:
+    """Search internal database for information."""
+    return f"Results for: {query}"
+
+@tool
+def calculate(expression: str) -> str:
+    """Safely evaluate a mathematical expression."""
+    import ast, operator
+    allowed = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul}
+    try:
+        tree = ast.parse(expression, mode='eval')
+        return str(allowed[type(tree.body.op)](eval(str(tree.body.left)), eval(str(tree.body.right))))
+    except:
+        return "Error"
+
+tools = [search_database, calculate]
+checkpointer = MemorySaver()
+
+agent = create_react_agent(llm, tools, checkpointer=checkpointer)
+
+config = {"configurable": {"thread_id": "user-123"}}
+result = await agent.ainvoke(
+    {"messages": [("user", "Search for tutorials and calculate 25 * 4")]},
+    config=config
+)
+```
+
+## Architecture Patterns
+
+### Pattern 1: RAG with LangGraph
+
+```python
+from langgraph.graph import StateGraph, START, END
+from langchain_anthropic import ChatAnthropic
+from langchain_voyageai import VoyageAIEmbeddings
+from langchain_pinecone import PineconeVectorStore
+from typing import TypedDict, Annotated
+
+class RAGState(TypedDict):
+    question: str
+    context: list
+    answer: str
+
+def retrieve(state: RAGState) -> RAGState:
+    retriever = PineconeVectorStore.from_existing_index(
+        index_name="docs",
+        embedding=VoyageAIEmbeddings(model="voyage-3-large")
+    ).as_retriever()
+    docs = retriever.invoke(state["question"])
+    return {"context": docs}
+
+def generate(state: RAGState) -> RAGState:
+    llm = ChatAnthropic(model="claude-sonnet-4-6")
+    prompt = f"Context: {state['context']}\nQuestion: {state['question']}"
+    response = llm.invoke(prompt)
+    return {"answer": response.content}
+
+graph = StateGraph(RAGState)
+graph.add_node("retrieve", retrieve)
+graph.add_node("generate", generate)
+graph.add_edge(START, "retrieve")
+graph.add_edge("retrieve", "generate")
+graph.add_edge("generate", END)
+
+app = graph.compile()
+```
+
+### Pattern 2: Plan-and-Execute Agent
+
+```python
+from langgraph.graph import StateGraph, START
+from typing import TypedDict
+
+class PlanExecuteState(TypedDict):
+    input: str
+    plan: list
+    past_steps: list
+    response: str
+
+planner_prompt = """Create a step-by-step plan for: {input}"""
+executor_prompt = """Execute step: {step}\nPrevious: {past_steps}"""
+
+def plan(state: PlanExecuteState) -> PlanExecuteState:
+    llm = ChatAnthropic(model="claude-sonnet-4-6")
+    response = llm.invoke(planner_prompt.format(input=state["input"]))
+    return {"plan": response.content.split("\n")}
+
+def execute(state: PlanExecuteState) -> PlanExecuteState:
+    # Execute current step
+    pass
+
+graph = StateGraph(PlanExecuteState)
+graph.add_node("plan", plan)
+graph.add_node("execute", execute)
+graph.add_edge(START, "plan")
+graph.add_edge("plan", "execute")
+```
+
+### Pattern 3: Multi-Agent Supervisor
+
+```python
+from langgraph.prebuilt import create_react_agent
+
+research_agent = create_react_agent(llm, [search_tool], state_schema=ResearchState)
+write_agent = create_react_agent(llm, [write_tool], state_schema=WriteState)
+
+def supervisor(state: AgentState) -> str:
+    """Route to appropriate agent."""
+    return "research" if "research" in state["messages"][-1].content else "write"
+
+graph = StateGraph(AgentState)
+graph.add_node("supervisor", supervisor)
+graph.add_node("research", research_agent)
+graph.add_node("write", write_agent)
+
+graph.add_edge(START, "supervisor")
+graph.add_conditional_edges("supervisor", 
+    lambda x: x["next"],
+    {"research": "research", "write": "write"})
+```
+
+### Pattern 4: Tool Calling Agent
+
+```python
+from langchain_anthropic import ChatAnthropic
+from langchain_core.utils.function_calling import convert_to_openai_function
+
+llm = ChatAnthropic(model="claude-sonnet-4-6")
+functions = [convert_to_openai_function(my_pydantic_model)]
+structured_llm = llm.bind_functions(functions)
+
+# Auto-invokes correct tool based on schema
+response = structured_llm.invoke("Extract info from: ...")
+```
+
+## Memory Patterns
+
+### Conversation Memory
+
+```python
+from langchain.memory import ConversationBufferMemory
+from langgraph.checkpoint.postgres import PostgresSaver
+
+# Short-term memory
+memory = ConversationBufferMemory(return_messages=True)
+
+# Long-term with PostgreSQL
+checkpointer = PostgresSaver.from_conn_string("postgresql://...")
+agent = create_react_agent(llm, tools, checkpointer=checkpointer)
+```
+
+### Summary Memory
+
+```python
+from langchain.memory import ConversationSummaryMemory
+
+memory = ConversationSummaryMemory(
+    llm=ChatAnthropic(model="claude-sonnet-4-6"),
+    return_messages=True
+)
+```
+
+## Best Practices
+
+1. **Use LangGraph** - Standard for production agents in 2026
+2. **Define typed state** - Use TypedDict for explicit state management
+3. **Checkpoint critical flows** - PostgresSaver for durability
+4. **Implement error handling** - Graph can handle failures gracefully
+5. **Use structured outputs** - Pydantic schemas for tools
+6. **Monitor with LangSmith** - Essential for production debugging
+7. **Modularize nodes** - Reusable components
+8. **Human-in-the-loop** - Allow inspection/modification