from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_google_genai import ChatGoogleGenerativeAI

# All models share the same interface
class BaseChatModel:
    def invoke(messages: List[BaseMessage]) -> BaseMessage
    def stream(messages: List[BaseMessage]) -> Iterator[BaseMessage]
    def batch(messages: List[List[BaseMessage]]) -> List[BaseMessage]

from langchain_core.runnables import RunnableSequence

# Declarative pipeline construction
chain = (
    prompt_template 
    | model 
    | output_parser
)

# Automatic parallelization
parallel = RunnableParallel({
    "summary": summarize_chain,
    "sentiment": sentiment_chain,
    "entities": entity_chain
})

from typing import TypedDict, Annotated
from langgraph.graph import add_messages

class AgentState(TypedDict):
    messages: Annotated[list, add_messages]
    intermediate_steps: list
    metadata: dict

from langgraph.checkpoint.postgres import PostgresSaver

# Production configuration
checkpointer = PostgresSaver.from_conn_string(
    "postgresql://user:pass@db/langchain"
)

agent = create_agent(
    model=model,
    tools=tools,
    checkpointer=checkpointer  # Durable execution enabled
)

from langchain import create_agent
from langchain_openai import ChatOpenAI
from langgraph.checkpoint.postgres import PostgresSaver

agent = create_agent(
    model=ChatOpenAI(model="gpt-4"),
    tools=[search_tool, calculator_tool, database_tool],
    prompt="You are a data analyst assistant.",
    middleware=[pii_middleware, logging_middleware],
    checkpointer=PostgresSaver.from_conn_string(DATABASE_URL),
    interrupt_before=["tools"],  # Human-in-the-loop
    max_iterations=25,
    max_execution_time=120.0
)

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_pinecone import PineconeVectorStore
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.tools import tool

class RAGSystem:
    def __init__(self, index_name: str):
        # Vector store for retrieval
        self.vectorstore = PineconeVectorStore.from_existing_index(
            index_name=index_name,
            embedding=OpenAIEmbeddings()
        )
        
        # Create retrieval tool
        @tool
        def search_knowledge_base(query: str) -> str:
            """Search the company knowledge base."""
            docs = self.vectorstore.similarity_search(query, k=5)
            return "\n\n".join([
                f"Document {i+1}:\n{doc.page_content}" 
                for i, doc in enumerate(docs)
            ])
        
        # Create agent with retrieval capability
        self.agent = create_agent(
            model=ChatOpenAI(model="gpt-4", temperature=0),
            tools=[search_knowledge_base],
            prompt="""You are a knowledgeable assistant with access to 
            the company knowledge base. Always search the knowledge base 
            before answering questions. Cite sources when possible.""",
            checkpointer=PostgresSaver.from_conn_string(os.getenv("DB_URL"))
        )
    
    def query(self, question: str, thread_id: str) -> str:
        """Execute RAG query"""
        config = {"configurable": {"thread_id": thread_id}}
        result = self.agent.invoke(
            {"messages": [{"role": "user", "content": question}]},
            config
        )
        return result["messages"][-1].content

# Use cheaper embeddings for large corpora
from langchain_community.embeddings import HuggingFaceEmbeddings

embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2"
)  # Free, runs locally

# Use tiered model strategy
cheap_model = ChatOpenAI(model="gpt-3.5-turbo")
expensive_model = ChatOpenAI(model="gpt-4")

# Route based on complexity
agent = create_agent(
    model=cheap_model,  # Default to cheaper model
    tools=[search_knowledge_base],
    middleware=[ModelRoutingMiddleware(expensive_model)]  # Upgrade when needed
)

class MultiAgentArchitecture:
    def __init__(self):
        # Specialized agents
        self.researcher = self._create_researcher()
        self.analyst = self._create_analyst()
        self.writer = self._create_writer()
        self.supervisor = self._create_supervisor()
    
    def _create_researcher(self):
        """Agent for gathering information"""
        return create_agent(
            model=ChatOpenAI(model="gpt-4"),
            tools=[web_search, document_reader, api_caller],
            prompt="You are a research specialist. Gather comprehensive data.",
            checkpointer=PostgresSaver.from_conn_string(
                os.getenv("DB_URL"), 
                namespace="researcher"
            )
        )
    
    def _create_analyst(self):
        """Agent for data analysis"""
        return create_agent(
            model=ChatOpenAI(model="gpt-4"),
            tools=[python_repl, data_visualizer],
            prompt="You are a data analyst. Analyze data and extract insights.",
            checkpointer=PostgresSaver.from_conn_string(
                os.getenv("DB_URL"),
                namespace="analyst"
            )
        )
    
    def _create_supervisor(self):
        """Orchestrating agent"""
        @tool
        def delegate_research(task: str) -> str:
            """Delegate to research agent"""
            return self.researcher.invoke(
                {"messages": [{"role": "user", "content": task}]},
                {"configurable": {"thread_id": f"research_{hash(task)}"}}
            )["messages"][-1].content
        
        @tool
        def delegate_analysis(task: str, data: str) -> str:
            """Delegate to analyst agent"""
            return self.analyst.invoke(
                {"messages": [{"role": "user", "content": f"{task}\n\nData:\n{data}"}]},
                {"configurable": {"thread_id": f"analysis_{hash(task)}"}}
            )["messages"][-1].content
        
        return create_agent(
            model=ChatOpenAI(model="gpt-4"),
            tools=[delegate_research, delegate_analysis],
            prompt="""You are a supervisor coordinating specialized agents.
            Break down complex tasks and delegate to appropriate agents.""",
            checkpointer=PostgresSaver.from_conn_string(os.getenv("DB_URL"))
        )

from langchain.middleware import HumanInTheLoopMiddleware

class ComplianceAgent:
    def __init__(self):
        # Define sensitive operations
        self.sensitive_operations = [
            "delete", "update_financial", "send_email", 
            "make_purchase", "change_permissions"
        ]
        
        # Create approval middleware
        hitl = HumanInTheLoopMiddleware(
            approval_required=self.sensitive_operations,
            timeout=300  # 5 minute approval window
        )
        
        # Create agent with HITL
        self.agent = create_agent(
            model=ChatOpenAI(model="gpt-4"),
            tools=self._get_tools(),
            middleware=[hitl],
            interrupt_before=["tools"],  # Pause before tool execution
            checkpointer=PostgresSaver.from_conn_string(os.getenv("DB_URL"))
        )
    
    def execute_with_approval(
        self, 
        request: str, 
        user_id: str,
        approver_callback: Callable
    ):
        """Execute request with approval workflow"""
        config = {"configurable": {"thread_id": f"user_{user_id}"}}
        
        # Start execution
        events = list(self.agent.stream(
            {"messages": [{"role": "user", "content": request}]},
            config
        ))
        
        # Check if approval needed
        if self._is_interrupted(events):
            # Extract pending action
            pending_action = self._extract_action(events)
            
            # Request approval
            approved = approver_callback(pending_action)
            
            if approved:
                # Resume execution
                result = self.agent.invoke(None, config)
                return result["messages"][-1].content
            else:
                return "Action cancelled by approver"
        
        # No approval needed, return result
        return events[-1]["messages"][-1].content

from langchain.middleware import BaseMiddleware

class BaseMiddleware:
    def pre_process(
        self,
        messages: List[BaseMessage],
        metadata: dict
    ) -> List[BaseMessage]:
        """Transform input before LLM"""
        pass
    
    def post_process(
        self,
        response: BaseMessage,
        metadata: dict
    ) -> BaseMessage:
        """Transform output after LLM"""
        pass

from langchain.middleware import PIIMiddleware

class ProductionPIIMiddleware(BaseMiddleware):
    """Enterprise-grade PII protection"""
    
    def __init__(self, mode: str = "redact"):
        self.detector = PIIDetector(
            entities=[
                "EMAIL", "PHONE", "SSN", "CREDIT_CARD",
                "IP_ADDRESS", "PERSON", "LOCATION", "DATE_OF_BIRTH"
            ],
            custom_patterns={
                "EMPLOYEE_ID": r"EMP-\d{6}",
                "CUSTOMER_ID": r"CUST-[A-Z0-9]{8}"
            }
        )
        self.mode = mode  # "redact", "block", or "encrypt"
    
    def pre_process(self, messages, metadata):
        """Scan input for PII"""
        for message in messages:
            detections = self.detector.scan(message.content)
            
            if detections and self.mode == "block":
                raise PIIViolationError(
                    f"PII detected in input: {detections}"
                )
            elif detections and self.mode == "redact":
                message.content = self.detector.redact(message.content)
            
            # Log for compliance
            metadata["pii_scan_result"] = detections
        
        return messages

class CostTrackingMiddleware(BaseMiddleware):
    """Track and enforce LLM costs"""
    
    def __init__(self, budget_per_user: float = 10.0):
        self.costs = {}  # user_id -> cost
        self.budget_per_user = budget_per_user
    
    def pre_process(self, messages, metadata):
        user_id = metadata.get("user_id")
        current_cost = self.costs.get(user_id, 0)
        
        if current_cost >= self.budget_per_user:
            raise BudgetExceededError(
                f"User {user_id} exceeded budget: ${current_cost:.2f}"
            )
        
        return messages
    
    def post_process(self, response, metadata):
        # Calculate cost
        tokens = metadata.get("token_usage", {})
        cost = self._calculate_cost(tokens)
        
        # Update tracking
        user_id = metadata.get("user_id")
        self.costs[user_id] = self.costs.get(user_id, 0) + cost
        
        # Add to response metadata
        metadata["cost"] = cost
        metadata["remaining_budget"] = self.budget_per_user - self.costs[user_id]
        
        return response
    
    def _calculate_cost(self, tokens: dict) -> float:
        """Calculate cost based on token usage"""
        # GPT-4 pricing (example)
        input_cost = tokens.get("prompt_tokens", 0) * 0.00003
        output_cost = tokens.get("completion_tokens", 0) * 0.00006
        return input_cost + output_cost

class SmartSummarizationMiddleware(BaseMiddleware):
    """Intelligently manage context length"""
    
    def __init__(self, max_tokens: int = 4000):
        self.max_tokens = max_tokens
        self.summarizer = ChatOpenAI(model="gpt-3.5-turbo")  # Cheaper model for summaries
    
    def pre_process(self, messages, metadata):
        token_count = self._count_tokens(messages)
        
        if token_count <= self.max_tokens:
            return messages
        
        # Keep system message and recent messages
        system_msg = messages[0] if messages[0].type == "system" else None
        recent_msgs = messages[-5:]  # Keep last 5 exchanges
        old_msgs = messages[1:-5] if len(messages) > 6 else []
        
        if old_msgs:
            # Summarize old conversation
            summary = self._generate_summary(old_msgs)
            
            return [
                system_msg,
                SystemMessage(content=f"[Previous conversation summary: {summary}]"),
                *recent_msgs
            ]
        
        return messages
    
    def _generate_summary(self, messages: List[BaseMessage]) -> str:
        """Generate conversation summary"""
        conversation_text = "\n".join([
            f"{msg.type}: {msg.content}" for msg in messages
        ])
        
        summary_prompt = f"""Summarize this conversation concisely, 
        preserving key facts and context:
        
        {conversation_text}
        
        Summary:"""
        
        return self.summarizer.invoke(summary_prompt).content

# Production middleware stack
agent = create_agent(
    model=ChatOpenAI(model="gpt-4"),
    tools=tools,
    middleware=[
        PIIMiddleware(mode="redact"),           # 1. Security first
        CostTrackingMiddleware(budget=50.0),    # 2. Cost control
        LoggingMiddleware(log_level="INFO"),    # 3. Observability
        SmartSummarizationMiddleware(),         # 4. Context management
        HumanInTheLoopMiddleware(               # 5. Compliance
            approval_required=["delete", "update"]
        )
    ],
    checkpointer=PostgresSaver.from_conn_string(os.getenv("DB_URL"))
)

import os

# Enable LangSmith tracing
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "your-api-key"
os.environ["LANGCHAIN_PROJECT"] = "production-agents"

# All agent executions automatically traced
agent = create_agent(model=model, tools=tools)

# View traces at smith.langchain.com

from langchain_core.callbacks import BaseCallbackHandler
from prometheus_client import Counter, Histogram

class MetricsCallback(BaseCallbackHandler):
    """Export metrics to Prometheus"""
    
    def __init__(self):
        self.llm_calls = Counter('agent_llm_calls_total', 'Total LLM calls')
        self.tool_calls = Counter('agent_tool_calls_total', 'Total tool calls', ['tool_name'])
        self.latency = Histogram('agent_latency_seconds', 'Agent response latency')
        self.errors = Counter('agent_errors_total', 'Total errors', ['error_type'])
    
    def on_llm_start(self, serialized, prompts, **kwargs):
        self.llm_calls.inc()
    
    def on_tool_start(self, serialized, input_str, **kwargs):
        tool_name = serialized.get("name", "unknown")
        self.tool_calls.labels(tool_name=tool_name).inc()
    
    def on_llm_error(self, error, **kwargs):
        error_type = type(error).__name__
        self.errors.labels(error_type=error_type).inc()

# Use in agent
metrics = MetricsCallback()
agent = create_agent(
    model=ChatOpenAI(model="gpt-4", callbacks=[metrics]),
    tools=tools
)

from fastapi import FastAPI
from langserve import add_routes
from langchain import create_agent

app = FastAPI(
    title="Agent API",
    version="1.0",
    description="Production agent API"
)

# Create agent
agent = create_agent(
    model=ChatOpenAI(model="gpt-4"),
    tools=tools,
    checkpointer=PostgresSaver.from_conn_string(os.getenv("DB_URL"))
)

# Add routes
add_routes(
    app,
    agent,
    path="/agent",
    enabled_endpoints=["invoke", "stream", "batch"],
    playground_type="chat"
)

# Health check
@app.get("/health")
def health_check():
    return {"status": "healthy"}

# Run with: uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4

# Dockerfile
FROM python:3.11-slim

WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application
COPY . .

# Non-root user
RUN useradd -m -u 1000 agent && chown -R agent:agent /app
USER agent

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:8000/health || exit 1

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

# docker-compose.yml
version: '3.8'

services:
  agent:
    build: .
    ports:
      - "8000:8000"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - DATABASE_URL=postgresql://user:pass@db:5432/langchain
      - LANGCHAIN_TRACING_V2=true
      - LANGCHAIN_API_KEY=${LANGCHAIN_API_KEY}
    depends_on:
      db:
        condition: service_healthy
    restart: unless-stopped
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 2G
  
  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=langchain
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U user"]
      interval: 10s
      timeout: 5s
      retries: 5
  
  redis:
    image: redis:7-alpine
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s

volumes:
  pgdata:

# k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: langchain-agent
spec:
  replicas: 3
  selector:
    matchLabels:
      app: langchain-agent
  template:
    metadata:
      labels:
        app: langchain-agent
    spec:
      containers:
      - name: agent
        image: your-registry/langchain-agent:latest
        ports:
        - containerPort: 8000
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: agent-secrets
              key: database-url
        - name: OPENAI_API_KEY
          valueFrom:
            secretKeyRef:
              name: agent-secrets
              key: openai-api-key
        resources:
          requests:
            memory: "1Gi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "1000m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: langchain-agent
spec:
  selector:
    app: langchain-agent
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8000
  type: LoadBalancer
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: langchain-agent-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: langchain-agent
  minReplicas: 3
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

class ModelRouter(BaseMiddleware):
    """Route to appropriate model based on complexity"""
    
    def __init__(self):
        self.cheap_model = ChatOpenAI(model="gpt-3.5-turbo")
        self.expensive_model = ChatOpenAI(model="gpt-4")
        self.complexity_classifier = self._train_classifier()
    
    def pre_process(self, messages, metadata):
        # Classify query complexity
        last_message = messages[-1].content
        complexity = self.complexity_classifier.predict(last_message)
        
        if complexity == "simple":
            metadata["model_override"] = self.cheap_model
        else:
            metadata["model_override"] = self.expensive_model
        
        return messages

from langchain.cache import SQLiteCache
from langchain_core.globals import set_llm_cache

# Enable semantic caching
set_llm_cache(SQLiteCache(database_path=".langchain.db"))

# Cache hits are free!
model = ChatOpenAI(model="gpt-4", cache=True)

# Process multiple requests in one batch
inputs = [
    {"messages": [{"role": "user", "content": query}]}
    for query in user_queries
]

# Batch invoke (more efficient)
results = agent.batch(
    inputs,
    config={"max_concurrency": 5}
)

class CostAnalyzer:
    """Analyze agent costs and optimize"""
    
    def generate_report(self, timeframe: str = "24h"):
        """Generate cost report"""
        costs = self._query_costs(timeframe)
        
        return {
            "total_cost": costs["total"],
            "cost_by_model": costs["by_model"],
            "cost_by_user": costs["by_user"],
            "cost_by_tool": costs["by_tool"],
            "recommendations": self._generate_recommendations(costs)
        }
    
    def _generate_recommendations(self, costs):
        """Generate optimization recommendations"""
        recommendations = []
        
        # Check if GPT-4 is overused
        if costs["by_model"].get("gpt-4", 0) > costs["total"] * 0.8:
            recommendations.append({
                "type": "model_optimization",
                "message": "Consider routing simple queries to GPT-3.5-turbo",
                "potential_savings": costs["by_model"]["gpt-4"] * 0.3
            })
        
        # Check for redundant tool calls
        if costs["by_tool"].get("redundant_calls", 0) > 100:
            recommendations.append({
                "type": "caching",
                "message": "Enable tool result caching",
                "potential_savings": costs["by_tool"]["redundant_calls"] * 0.02
            })
        
        return recommendations

class PrivacyCompliantAgent:
    """Agent designed for regulated industries"""
    
    def __init__(self):
        self.agent = create_agent(
            model=ChatOpenAI(model="gpt-4"),
            tools=self._get_compliant_tools(),
            middleware=[
                PIIMiddleware(mode="redact"),
                DataResidencyMiddleware(region="EU"),
                AuditLoggingMiddleware(),
                EncryptionMiddleware(key=os.getenv("ENCRYPTION_KEY"))
            ],
            checkpointer=EncryptedPostgresSaver.from_conn_string(
                os.getenv("DB_URL")
            )
        )
    
    def _get_compliant_tools(self):
        """Tools that meet compliance requirements"""
        return [
            self._create_anonymized_search(),
            self._create_secure_database_access(),
            self._create_audit_logged_email()
        ]

import pytest
from unittest.mock import Mock, patch

class TestAgentBehavior:
    """Test suite for agent logic"""
    
    @pytest.fixture
    def mock_model(self):
        """Mock LLM for testing"""
        model = Mock()
        model.invoke.return_value = AIMessage(
            content="Test response",
            tool_calls=[{
                "name": "search",
                "args": {"query": "test"}
            }]
        )
        return model
    
    @pytest.fixture
    def agent(self, mock_model):
        """Create agent with mocked components"""
        return create_agent(
            model=mock_model,
            tools=[self.mock_search_tool()],
            checkpointer=MemorySaver()
        )
    
    def mock_search_tool(self):
        @tool
        def mock_search(query: str) -> str:
            """Mock search tool"""
            return f"Mock results for: {query}"
        return mock_search
    
    def test_agent_uses_tools(self, agent):
        """Test that agent correctly uses tools"""
        result = agent.invoke(
            {"messages": [{"role": "user", "content": "Search for AI"}]},
            {"configurable": {"thread_id": "test"}}
        )
        
        # Verify tool was called
        assert "Mock results" in str(result)
    
    def test_agent_handles_errors(self, agent):
        """Test error handling"""
        with patch.object(agent, 'invoke', side_effect=Exception("Test error")):
            with pytest.raises(Exception):
                agent.invoke({"messages": []})

class TestRAGPipeline:
    """Integration tests for RAG system"""
    
    @pytest.fixture
    def rag_system(self):
        """Set up real RAG system for integration tests"""
        # Use test index
        return RAGSystem(index_name="test-index")
    
    def test_end_to_end_query(self, rag_system):
        """Test complete RAG flow"""
        response = rag_system.query(
            "What is the return policy?",
            thread_id="integration_test"
        )
        
        # Verify response quality
        assert len(response) > 0
        assert "return" in response.lower()
    
    @pytest.mark.slow
    def test_concurrent_queries(self, rag_system):
        """Test system under load"""
        import concurrent.futures
        
        queries = [f"Test query {i}" for i in range(100)]
        
        with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
            futures = [
                executor.submit(
                    rag_system.query, 
                    query, 
                    f"thread_{i}"
                )
                for i, query in enumerate(queries)
            ]
            
            results = [f.result() for f in futures]
        
        # All queries should succeed
        assert len(results) == 100
        assert all(len(r) > 0 for r in results)

from langchain.evaluation import load_evaluator

class AgentEvaluator:
    """Evaluate agent quality"""
    
    def __init__(self):
        self.criteria_evaluator = load_evaluator("criteria")
        self.qa_evaluator = load_evaluator("qa")
    
    def evaluate_helpfulness(self, query: str, response: str) -> float:
        """Evaluate response helpfulness"""
        result = self.criteria_evaluator.evaluate_strings(
            prediction=response,
            input=query,
            criteria="helpfulness"
        )
        return result["score"]
    
    def evaluate_accuracy(
        self, 
        query: str, 
        response: str, 
        reference: str
    ) -> float:
        """Evaluate response accuracy"""
        result = self.qa_evaluator.evaluate_strings(
            prediction=response,
            input=query,
            reference=reference
        )
        return result["score"]
    
    def run_evaluation_suite(self, agent, test_cases: list):
        """Run comprehensive evaluation"""
        results = []
        
        for test_case in test_cases:
            response = agent.invoke(
                {"messages": [{"role": "user", "content": test_case["query"]}]},
                {"configurable": {"thread_id": f"eval_{test_case['id']}"}}
            )["messages"][-1].content
            
            results.append({
                "test_id": test_case["id"],
                "query": test_case["query"],
                "response": response,
                "helpfulness": self.evaluate_helpfulness(
                    test_case["query"], 
                    response
                ),
                "accuracy": self.evaluate_accuracy(
                    test_case["query"],
                    response,
                    test_case["expected_answer"]
                )
            })
        
        return self._generate_report(results)

# OLD (0.x)
from langchain.agents import initialize_agent, AgentType
from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.CHAT_CONVERSATIONAL_REACT_DESCRIPTION,
    memory=memory,
    verbose=True
)

result = agent.run("Hello")

# NEW (1.x)
from langchain import create_agent
from langgraph.checkpoint.sqlite import SqliteSaver

agent = create_agent(
    model=llm,  # Changed from 'llm' to 'model'
    tools=tools,
    prompt="You are a helpful assistant",
    checkpointer=SqliteSaver.from_conn_string(":memory:")
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Hello"}]},
    {"configurable": {"thread_id": "session_1"}}
)

# OLD (0.x)
from langchain.chains import LLMChain

chain = LLMChain(llm=llm, prompt=prompt)
result = chain.run({"input": "test"})

# NEW (1.x) - Use LCEL
chain = prompt | llm | parser
result = chain.invoke({"input": "test"})

# OLD (0.x)
from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()

# NEW (1.x) - Use checkpointer
from langgraph.checkpoint.postgres import PostgresSaver

checkpointer = PostgresSaver.from_conn_string("postgresql://...")

class CustomerSupportAgent:
    def __init__(self):
        # Tools
        @tool
        def search_knowledge_base(query: str) -> str:
            """Search help articles and documentation"""
            return knowledge_base.search(query)
        
        @tool
        def lookup_order(order_id: str) -> str:
            """Get order details and status"""
            return order_system.get_order(order_id)
        
        @tool
        def create_ticket(issue: str, priority: str) -> str:
            """Escalate to human support"""
            return ticketing_system.create(issue, priority)
        
        # Agent with support-specific middleware
        self.agent = create_agent(
            model=ChatOpenAI(model="gpt-4"),
            tools=[
                search_knowledge_base,
                lookup_order,
                create_ticket
            ],
            prompt="""You are a helpful customer support agent.
            
            Guidelines:
            - Be empathetic and professional
            - Search knowledge base before answering
            - Look up order details when customer provides order ID
            - Escalate complex issues to human support
            - Always confirm resolution before ending conversation
            """,
            middleware=[
                LanguageDetectionMiddleware(),
                SentimentAnalysisMiddleware(),
                EscalationMiddleware(threshold=0.7),
                ResponseTimeMiddleware(max_seconds=10)
            ],
            checkpointer=PostgresSaver.from_conn_string(os.getenv("DB_URL"))
        )

class DataAnalysisAgent:
    def __init__(self):
        @tool
        def query_database(sql: str) -> str:
            """Execute SQL query and return results"""
            # Validation and safety checks
            if not self._is_safe_query(sql):
                return "Error: Query not allowed"
            return database.execute(sql)
        
        @tool
        def create_visualization(data: str, chart_type: str) -> str:
            """Generate chart from data"""
            return visualization_service.create(data, chart_type)
        
        @tool
        def run_statistical_test(data: str, test_type: str) -> str:
            """Perform statistical analysis"""
            return stats_service.run_test(data, test_type)
        
        self.agent = create_agent(
            model=ChatOpenAI(model="gpt-4"),
            tools=[
                query_database,
                create_visualization,
                run_statistical_test
            ],
            prompt="""You are a data analysis expert.
            
            When analyzing data:
            1. Understand the business question
            2. Query the appropriate tables
            3. Perform relevant analysis
            4. Create visualizations
            5. Provide actionable insights
            """,
            middleware=[
                SQLValidationMiddleware(),
                DataPrivacyMiddleware(),
                ResultCachingMiddleware()
            ],
            checkpointer=PostgresSaver.from_conn_string(os.getenv("DB_URL"))
        )

class DocumentProcessingPipeline:
    def __init__(self):
        # Specialized agents for different tasks
        self.classifier = self._create_classifier_agent()
        self.extractor = self._create_extractor_agent()
        self.validator = self._create_validator_agent()
        self.orchestrator = self._create_orchestrator_agent()
    
    def _create_extractor_agent(self):
        """Agent for extracting structured data"""
        return create_agent(
            model=ChatOpenAI(model="gpt-4"),
            tools=[ocr_tool, table_extraction_tool],
            prompt="""Extract structured information from documents.
            
            Extract:
            - Key entities (names, dates, amounts)
            - Tables and structured data
            - Metadata
            
            Return as JSON."""
        )
    
    def process_document(self, document_path: str):
        """Process a document through the pipeline"""
        # 1. Load document
        doc = self._load_document(document_path)
        
        # 2. Classify
        doc_type = self.classifier.invoke({
            "messages": [{"role": "user", "content": f"Classify: {doc.text[:1000]}"}]
        })
        
        # 3. Extract based on type
        extracted_data = self.extractor.invoke({
            "messages": [{"role": "user", "content": f"Extract from {doc_type}: {doc.text}"}]
        })
        
        # 4. Validate
        validated_data = self.validator.invoke({
            "messages": [{"role": "user", "content": f"Validate: {extracted_data}"}]
        })
        
        # 5. Store
        return self._store_in_knowledge_base(validated_data)