Anthropic Claude Agent SDK Integration for AI Agents

Integration of Anthropic Claude Agent SDK for Building AI Agents

Let's be direct: when a client comes with a task to build an agent that doesn't just answer questions but performs actions—searching databases, creating tickets, working with files—we know that the Anthropic Claude Agent SDK removes 80% of the grunt work. But incorrect integration leads to context loss and hallucinations. Here's how we configure the SDK to make the agent reliable in production. Our team has 5+ years of experience in NLP and LLMs, with over 20 projects using the Claude Agent SDK. We guarantee stable agent operation in your infrastructure.

Problems We Solve

• Context drift in multi-turn dialogs: Without proper session management, the agent forgets previous interactions, causing repetitive questions or incorrect actions. The SDK's built-in ConversationSession handles this automatically.
• Tool integration complexity: Manually wrapping each API call with error handling, retries, and parsing is error-prone and time-consuming. The @tool decorator streamlines this.
• Lack of human oversight for critical operations: Destructive actions like deleting orders or processing refunds need approval. The SDK's ToolApprovalPolicy provides a clean interface for human-in-the-loop.

How We Do It: Technical Details

We start by installing the SDK and defining tools via decorators. Below is a typical template we use.

# pip install anthropic claude-agent-sdk
import anthropic
from claude_agent_sdk import Agent, AgentConfig, tool

client = anthropic.Anthropic()

@tool
def search_database(query: str, table: str = "products") -> str:
    """Search the company database.

    Args:
        query: Search query
        table: Table to search (products, orders, customers)
    """
    results = db.search(query=query, table=table, limit=10)
    return results.to_json()

@tool
def create_support_ticket(
    customer_id: str,
    subject: str,
    description: str,
    priority: str = "normal",
) -> str:
    """Create a support ticket.

    Args:
        customer_id: Customer ID
        subject: Ticket subject
        description: Detailed description
        priority: Priority (low, normal, high, critical)
    """
    ticket = helpdesk.create_ticket(
        customer_id=customer_id,
        subject=subject,
        description=description,
        priority=priority,
    )
    return f"Ticket #{ticket['id']} created. URL: {ticket['url']}"

config = AgentConfig(
    model="claude-opus-4-5",
    system_prompt="""You are a customer support agent for TechCorp.
Help customers solve problems using available tools.
Always verify data through tools—do not rely on memory.""",
    max_turns=10,
)

agent = Agent(
    client=client,
    config=config,
    tools=[search_database, create_support_ticket],
)

result = agent.run(
    messages=[{"role": "user", "content": "Customer ID 12345 has a problem with order #99876"}]
)
print(result.final_message)

For real-time interactions, we use streaming via astream.

import asyncio

async def run_agent_with_streaming():
    async for event in agent.astream(
        messages=[{"role": "user", "content": "Analyze the last 10 orders for customer ID 12345"}]
    ):
        match event.type:
            case "text_delta":
                print(event.text, end="", flush=True)
            case "tool_use_start":
                print(f"\n[Tool: {event.tool_name}]")
            case "tool_result":
                print(f"[Result received, {len(event.content)} chars]")
            case "agent_turn_complete":
                print(f"\n[Completed in {event.turn_count} turns]")

asyncio.run(run_agent_with_streaming())

MCP Integration

Model Context Protocol (MCP) allows connecting external servers with tools without explicit coding. We use this for filesystem, database, and GitHub integration.

from claude_agent_sdk import Agent, MCPServerConfig

agent_with_mcp = Agent(
    client=client,
    config=config,
    mcp_servers=[
        MCPServerConfig(
            name="filesystem",
            command="npx",
            args=["-y", "@modelcontextprotocol/server-filesystem", "/workspace"],
        ),
        MCPServerConfig(
            name="postgres",
            command="npx",
            args=["-y", "@modelcontextprotocol/server-postgres"],
            env={"POSTGRES_URL": "postgresql://user:pass@localhost/db"},
        ),
        MCPServerConfig(
            name="github",
            command="npx",
            args=["-y", "@modelcontextprotocol/server-github"],
            env={"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."},
        ),
    ],
)

result = agent_with_mcp.run(
    messages=[{"role": "user", "content": "Read the file config.yaml and create GitHub Issues from TODO comments"}]
)

Multi-Turn Dialog with History

We use ConversationSession to maintain context across turns without manual history management.

from claude_agent_sdk import ConversationSession

session = ConversationSession(
    agent=agent,
    session_id="customer_session_12345",
)

response1 = session.send("What is the status of my order #99876?")
response2 = session.send("Can I reschedule delivery for tomorrow?")
response3 = session.send("Please confirm")

print(session.get_history())

Human-in-the-Loop via Approval

For destructive operations, we require approval. The ToolApprovalPolicy lets us define which tools need confirmation.

from claude_agent_sdk import Agent, ToolApprovalPolicy

class CustomApprovalPolicy(ToolApprovalPolicy):
    REQUIRES_APPROVAL = {"delete_order", "process_refund", "ban_customer"}

    async def should_approve(self, tool_name: str, tool_input: dict) -> bool:
        if tool_name not in self.REQUIRES_APPROVAL:
            return True
        await notify_operator(
            message=f"Approval required: {tool_name}\nParameters: {tool_input}",
            callback_url="/api/approve/{approval_id}",
        )
        approval = await wait_for_approval(timeout=300)
        return approval.approved

agent_with_approval = Agent(
    client=client,
    config=config,
    tools=[search_database, process_refund, ban_customer],
    approval_policy=CustomApprovalPolicy(),
)

Practical Case: Financial Monitoring Agent

Comparison: Manual Implementation vs. Claude Agent SDK

Using the SDK cuts agent development time by three times compared to manual implementation. Based on our data, clients achieve substantial annual savings on manual processing.

Common Mistakes and Solutions

Process and Timeline

• Architectural design of the agent for your scenario — 1–2 days.
• SDK integration with your infrastructure and tool setup — 3–5 days.
• Connecting MCP servers (files, databases, external APIs) — 1–3 days each.
• Setting up human-in-the-loop and approval flow — 1 week.
• Documentation and team training — 2–3 days.
• Production deployment with monitoring — 1 week.
• Support for 1 month after deployment is included.

Total timeline: 2 to 4 weeks depending on complexity. Exact cost is calculated individually after analyzing your scenario.

What You Get

• A working agent with configured tools and MCP servers.
• Full documentation on architecture and API.
• Access to source code and CI/CD pipeline.
• Team training (2–3 sessions).
• One month of technical support after deployment.

Why Integrate the Claude Agent SDK?

The SDK provides out-of-the-box mechanisms for context management, tools, and security, accelerating production release by three times. According to an internal client survey, ticket processing time decreases by 60%. Contact us to assess your scenario and schedule a consultation for integration.