Real-World Agent Projects

from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma

# Set up RAG over support documentation
embeddings = OpenAIEmbeddings()
vectorstore = Chroma(
    collection_name="support_docs",
    embedding_function=embeddings,
)

def classify_intent(state):
    """Classify customer intent."""
    llm = ChatOpenAI(model="gpt-4")
    intent = llm.invoke(
        f"Classify this support request: {state['query']}\n"
        "Categories: billing, technical, general, escalate"
    )
    return {"intent": intent.content.strip()}

def search_knowledge_base(state):
    """Search documentation for relevant answers."""
    docs = vectorstore.similarity_search(state["query"], k=3)
    return {"context": [d.page_content for d in docs]}

def generate_response(state):
    """Generate response using RAG context."""
    llm = ChatOpenAI(model="gpt-4")
    response = llm.invoke(
        f"Answer this customer question: {state['query']}\n"
        f"Using this context: {state['context']}\n"
        "Be helpful, empathetic, and concise."
    )
    return {"response": response.content}

# Build the service agent graph
graph = StateGraph(ServiceState)
graph.add_node("classify", classify_intent)
graph.add_node("search", search_knowledge_base)
graph.add_node("respond", generate_response)
graph.add_node("escalate", escalate_to_human)

graph.set_entry_point("classify")
graph.add_conditional_edges("classify", route_by_intent, {
    "billing": "search",
    "technical": "search",
    "general": "respond",
    "escalate": "escalate",
})
graph.add_edge("search", "respond")
graph.add_edge("respond", END)

import anthropic
from claude_agent_sdk import Agent, tool

@tool
def read_file(path: str) -> str:
    """Read a file from the project."""
    with open(path) as f:
        return f.read()

@tool
def run_tests(test_path: str) -> str:
    """Run pytest on a test file."""
    result = subprocess.run(
        ["pytest", test_path, "-v"],
        capture_output=True, text=True, timeout=30
    )
    return result.stdout + result.stderr

@tool
def write_file(path: str, content: str) -> str:
    """Write content to a file."""
    with open(path, "w") as f:
        f.write(content)
    return f"Written {len(content)} chars to {path}"

coding_agent = Agent(
    client=anthropic.Anthropic(),
    model="claude-sonnet-4-20250514",
    system_prompt="""You are an expert coding assistant.
    Read code, understand context, suggest improvements,
    write tests, and fix bugs. Always run tests after changes.""",
    tools=[read_file, run_tests, write_file],
    max_turns=15,
)

from openai import OpenAI

client = OpenAI()

# Create data analysis assistant with code interpreter
assistant = client.beta.assistants.create(
    name="Data Analyst",
    instructions="""You are an expert data analyst. When given data:
    1. Explore and summarize the dataset
    2. Answer the user's question with analysis
    3. Create visualizations when helpful
    4. Provide actionable insights""",
    model="gpt-4-turbo",
    tools=[{"type": "code_interpreter"}],
)

# Upload data and analyze
file = client.files.create(
    file=open("sales_data.csv", "rb"),
    purpose="assistants",
)

thread = client.beta.threads.create()
client.beta.threads.messages.create(
    thread_id=thread.id,
    role="user",
    content="What are the top 5 products by revenue this quarter?",
    attachments=[{"file_id": file.id, "tools": [{"type": "code_interpreter"}]}],
)

run = client.beta.threads.runs.create_and_poll(
    thread_id=thread.id,
    assistant_id=assistant.id,
)