# Option A: NPM (cross-platform)
npm install -g @anthropic-ai/claude-code

# Option B: curl installer (Linux / macOS)
curl -fsSL https://claude.ai/install.sh | bash

# Option C: Homebrew (macOS)
brew install anthropic/tap/claude-code

# Verify installation
claude --version
claude doctor

# Download and run the installer
irm https://claude.ai/install.ps1 | iex

# Then add to PATH: C:Users<user>.localbin
# Restart PowerShell, then verify:
claude --version

# Set for current session
export ANTHROPIC_API_KEY="sk-ant-your-key-here"

# Persist in shell profile (bash/zsh)
echo 'export ANTHROPIC_API_KEY="sk-ant-your-key-here"' >> ~/.zshrc

# OR use a .env file (recommended for projects)
echo "ANTHROPIC_API_KEY=sk-ant-your-key-here" > .env

# Install the Anthropic Python SDK
pip install anthropic python-dotenv

# Install the Claude Agent SDK (for agent loop features)
pip install claude-code-sdk

# Create a new project
mkdir my-claude-agent && cd my-claude-agent
npm init -y

# Install SDKs and TypeScript tooling
npm install @anthropic-ai/sdk @anthropic-ai/claude-agent-sdk
npm install -D typescript @types/node tsx

import os
import anthropic
from dotenv import load_dotenv

load_dotenv()
client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def ask_claude(prompt: str) -> str:
    message = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        messages=[
            {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

# Quick test
print(ask_claude("What is 2 + 2? Answer in one word."))

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    system="You are a helpful coding assistant.",  # System prompt
    messages=[
        {"role": "user", "content": "Write a Python function to reverse a string"},
        {"role": "assistant", "content": "def reverse_string(s): return s[::-1]"},
        {"role": "user", "content": "Add input validation"}
    ]
)

tools = [
    {
        "name": "calculator",
        "description": "Performs basic arithmetic. Use this for any math operations.",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {
                    "type": "string",
                    "description": "Math expression to evaluate, e.g. '15 * 24 + 100'"
                }
            },
            "required": ["expression"]
        }
    },
    {
        "name": "web_search",
        "description": "Searches the web for current information on a topic.",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "The search query"}
            },
            "required": ["query"]
        }
    },
    {
        "name": "save_to_file",
        "description": "Saves text content to a local file.",
        "input_schema": {
            "type": "object",
            "properties": {
                "filename": {"type": "string"},
                "content": {"type": "string"}
            },
            "required": ["filename", "content"]
        }
    }
]

import math

def calculator(expression: str) -> str:
    try:
        allowed = {k: v for k, v in math.__dict__.items()
                   if not k.startswith("__")}
        result = eval(expression, {"__builtins__": {}}, allowed)
        return f"Result: {result}"
    except Exception as e:
        return f"Error: {str(e)}"

def web_search(query: str) -> str:
    # In production: wire to SerpAPI, Tavily, or Brave Search
    return f"Search results for '{query}': [relevant results here]"

def save_to_file(filename: str, content: str) -> str:
    try:
        with open(filename, 'w') as f:
            f.write(content)
        return f"Successfully saved to {filename}"
    except Exception as e:
        return f"Error saving file: {str(e)}"

# Tool dispatcher — routes tool calls to implementations
def execute_tool(tool_name: str, tool_input: dict) -> str:
    if tool_name == "calculator":
        return calculator(tool_input["expression"])
    elif tool_name == "web_search":
        return web_search(tool_input["query"])
    elif tool_name == "save_to_file":
        return save_to_file(tool_input["filename"], tool_input["content"])
    else:
        return f"Unknown tool: {tool_name}"

def run_agent(user_query: str, max_iterations: int = 10) -> str:
    print(f"nUser: {user_query}")
    messages = [{"role": "user", "content": user_query}]
    system_prompt = """You are a helpful AI agent with access to tools.
    Think step by step. Use tools when you need real data or calculations.
    When you have enough information, provide a clear final answer."""

    for iteration in range(max_iterations):
        print(f"n[Iteration {iteration + 1}]")
        # Call Claude with tools
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=4096,
            system=system_prompt,
            tools=tools,
            messages=messages
        )
        print(f"Stop reason: {response.stop_reason}")

        # If Claude finished reasoning, extract and return the answer
        if response.stop_reason == "end_turn":
            final_answer = ""
            for block in response.content:
                if hasattr(block, 'text'):
                    final_answer += block.text
            return final_answer

        # If Claude wants to use tools
        if response.stop_reason == "tool_use":
            messages.append({"role": "assistant", "content": response.content})
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    print(f"  Tool: {block.name} | Input: {block.input}")
                    result = execute_tool(block.name, block.input)
                    print(f"  Result: {result}")
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": result
                    })
            messages.append({"role": "user", "content": tool_results})

    return "Max iterations reached without a final answer."

# Run the agent
result = run_agent("What is 15% of 847 and save the result to result.txt?")
print(f"nFinal Answer: {result}")

// Without SDK: You manage the loop manually
let response = await client.messages.create({...});
while (response.stop_reason === "tool_use") {
  const result = yourToolExecutor(response.tool_use);
  response = await client.messages.create({ tool_result: result, ... });
}

// With the SDK: Claude manages the loop for you
for await (const message of query({ prompt: "Fix the bug in auth.py" })) {
  console.log(message); // Claude reads files, finds bugs, edits code automatically
}

import { query } from "@anthropic-ai/claude-agent-sdk";

async function main() {
  for await (const message of query({
    prompt: "What files are in this directory? Summarise each one.",
    options: {
      model: "claude-sonnet-4-6",
      allowedTools: ["Glob", "Read"],
      maxTurns: 250
    }
  })) {
    if (message.type === "assistant") {
      for (const block of message.message.content) {
        if ("text" in block) console.log(block.text);
      }
    }
    if (message.type === "result") {
      console.log("Done: " + message.subtype + " | Cost: $" + message.total_cost_usd);
    }
  }
}

main();

import asyncio
from claude_code_sdk import query, ClaudeCodeOptions

async def run_agent():
    async for message in query(
        prompt="Analyse the Python files in this directory and find any bugs",
        options=ClaudeCodeOptions(
            model="claude-sonnet-4-6",
            allowed_tools=["Read", "Glob", "Grep"],
            max_turns=50,
            system_prompt="You are a senior Python engineer. Be thorough."
        )
    ):
        if message.type == "assistant":
            for block in message.message.content:
                if hasattr(block, 'text'):
                    print(block.text, end="", flush=True)
        elif message.type == "result":
            print(f"nComplete — Cost: ${message.total_cost_usd:.4f}")

asyncio.run(run_agent())

import { query } from "@anthropic-ai/claude-agent-sdk";

async function reviewCode(directory: string) {
  console.log("Starting code review for: " + directory);

  for await (const message of query({
    prompt: "Review the code in " + directory + " for: 1) bugs, 2) security issues, 3) performance, 4) code quality. Be specific about file names and line numbers.",
    options: {
      model: "claude-opus-4-8",
      allowedTools: ["Read", "Glob", "Grep"],
      permissionMode: "bypassPermissions",
      maxTurns: 250
    }
  })) {
    if (message.type === "assistant") {
      for (const block of message.message.content) {
        if ("text" in block) console.log(block.text);
        else if ("name" in block) console.log("Using: " + block.name);
      }
    }
  }
}

reviewCode(".");

# Install the Managed Agents CLI (ant)
brew install anthropic/tap/ant       # macOS
curl -fsSL https://claude.ai/install.sh | bash  # Linux

# Verify
ant --version

# Install Python SDK
pip install anthropic

# Set API key
export ANTHROPIC_API_KEY="your-api-key-here"

from anthropic import Anthropic
client = Anthropic()

agent = client.beta.agents.create(
    name="Coding Assistant",
    model="claude-sonnet-4-6",
    system="You are a helpful coding assistant. Write clean, well-documented code.",
    tools=[
        {"type": "agent_toolset_20260401"},  # Full built-in toolset
    ],
)
print(f"Agent ID: {agent.id}")

environment = client.beta.environments.create(
    name="quickstart-env",
    config={
        "type": "cloud",
        "networking": {"type": "unrestricted"},
        # In production: restrict to specific domains
        # "networking": {"type": "restricted", "allowed_domains": ["api.example.com"]}
    },
)
print(f"Environment ID: {environment.id}")

import anthropic
client = anthropic.Anthropic()

session = client.beta.sessions.create(
    agent_id="agent_abc123",
    environment_id="env_xyz456",
)

with client.beta.sessions.send_message.stream(
    session_id=session.id,
    content="Create a simple Python web scraper for https://httpbin.org/json"
) as stream:
    for event in stream:
        if event.type == "content_block_delta":
            print(event.delta.text, end="", flush=True)
        elif event.type == "tool_use":
            print(f"nTool: {event.tool_name}({event.tool_input})")
        elif event.type == "message_stop":
            print("nSession complete")

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    tools=[
        {
            "type": "mcp",
            "server_label": "github",
            "server_url": "https://mcp.github.com",
            "authorization_token": os.getenv("GITHUB_TOKEN"),
            "allowed_tools": ["list_repos", "create_issue", "get_file_contents"]
        }
    ],
    messages=[{"role": "user", "content": "List my recent GitHub repos"}]
)

# Create a new skill project
ant beta:skills init my-data-skill

# Define tools in skill.yaml, implement in index.ts/main.py
# Then deploy:
ant beta:skills deploy

# Attach to an agent
ant beta:agents update AGENT_ID 
  --skill 'my-data-skill@1.0.0'

import asyncio
from anthropic import Anthropic
client = Anthropic()

async def run_subagent(agent_id: str, env_id: str, task: str) -> str:
    """Run a single subagent and return its final output."""
    session = client.beta.sessions.create(
        agent_id=agent_id,
        environment_id=env_id,
    )
    result = ""
    with client.beta.sessions.send_message.stream(
        session_id=session.id, content=task
    ) as stream:
        for event in stream:
            if event.type == "content_block_delta":
                result += event.delta.text
    return result

async def orchestrate_research(topic: str) -> str:
    subtasks = [
        f"Research the history of {topic} from primary sources",
        f"Find recent developments and news about {topic} in 2025-2026",
        f"Analyse the technical aspects and future outlook of {topic}",
    ]
    # Run subagents in parallel
    results = await asyncio.gather(*[
        run_subagent("agent_research_worker", "env_sandbox", task)
        for task in subtasks
    ])
    combined = "nn---nn".join(results)
    return await run_subagent(
        "agent_synthesiser", "env_sandbox",
        f"Synthesise these research results into a coherent report:nn{combined}"
    )

report = asyncio.run(orchestrate_research("quantum computing"))

# Role
You are an invoice processing agent for Acme Corp.

# Inputs & Outputs
Input: Email messages containing invoice attachments (PDF)
Output: Structured JSON with vendor, amount, due_date, line items

# Tool Usage
1. Use read_email to fetch the latest unprocessed invoice emails
2. Use extract_pdf to parse the PDF attachment
3. Use validate_vendor to confirm the vendor exists in our system
4. Use save_to_db to persist the structured record

# Guardrails (NEVER DO)
- Do NOT send any emails or notifications
- Do NOT approve or reject invoices — only extract data
- Do NOT access any files outside the invoices/ directory
- If the invoice total exceeds $50,000, flag for human review
- If vendor is not found, escalate — do not create new vendors