Claude Notes

npm install -g @anthropic-ai/claude-code

claude  # Opens browser for Anthropic login on first run

export ANTHROPIC_API_KEY=sk-ant-...

claude --version
claude --help

claude                              # Start new interactive session
claude "fix the authentication bug" # Start session with initial prompt
claude -p "explain this function"   # One-shot query, then exit (non-interactive)
claude -c                           # Continue the most recent session
claude --resume                     # Pick a past session to resume

claude --model opus          # Use Claude Opus (most capable)
claude --model sonnet        # Use Claude Sonnet (balanced)
claude --model haiku          # Use Claude Haiku (fastest, cheapest)

claude --allowedTools "Read" "Write" "Bash"     # Skip dialog for these tools
claude --disallowedTools "Write"                 # Remove a tool entirely
claude --dangerously-skip-permissions            # Skip ALL permission dialogs (use with extreme caution)
claude --permission-mode plan                    # Start in plan-only mode

claude --system-prompt "You are a React expert"            # Replace system prompt
claude --append-system-prompt "Never delete test files"    # Add to system prompt
claude --agent MyCustomAgent                               # Use a specific sub-agent

claude -p "analyze code" --output-format json              # JSON output
claude -p "review" --max-turns 5 > report.txt             # Limit turns, pipe output
claude -p "audit" --allowedTools Read,Grep,Glob \
  --output-format json > security_report.json

claude --worktree feature-auth   # Create isolated git worktree for this session

/help          # List all available commands including custom ones
/model         # Switch AI model for current session
/clear         # Clear context window (start fresh)
/compact       # Summarize + clear context (retains summary)
/compact retain the error handling patterns  # Compact with specific retention
/context       # View context window stats and usage %
/usage         # View plan usage / remaining quota
/init          # Analyze project and generate CLAUDE.md
/mcp           # View and manage connected MCP servers
/permissions   # View and update permission settings
/rewind        # Undo to earlier conversation point
/config        # Open interactive settings menu
/statusline    # Configure the terminal status bar

~/.claude/CLAUDE.md              # Global — applies to ALL your projects
your-project/CLAUDE.md           # Project — shared via Git with team
your-project/CLAUDE.local.md     # Local — personal overrides, NOT in Git

# Project: E-Commerce API

## Tech Stack

- Python 3.12 + FastAPI + SQLAlchemy
- PostgreSQL (primary DB), Redis (cache)
- Docker for local dev, AWS ECS for production

## Code Conventions

- Use type hints everywhere — no untyped functions
- Snake_case for variables, PascalCase for classes
- Write docstrings for all public functions
- Tests in `/tests` mirroring the src structure
- Use pytest with fixtures, not unittest

## Architecture Rules

- All DB access goes through the repository pattern
- Business logic in services, NOT in route handlers
- Never return raw SQLAlchemy models — use Pydantic schemas

## DO NOT

- Modify `.env` or `.env.example` files
- Delete or alter database migration files
- Change any `*_schema.py` files without asking
- Push directly to `main` branch — always create a PR

## Running the Project

- Start: `docker-compose up`
- Tests: `pytest -v`
- Migrations: `alembic upgrade head`
- Lint: `ruff check .`

.claude/
└── rules/
    ├── code-style.md
    ├── security.md
    ├── testing.md
    └── git-workflow.md

~/.claude.json                          # Global user settings
~/.claude/settings.json                 # Global Claude Code settings
your-project/.claude/settings.json      # Project-shared settings (commit to Git)
your-project/.claude/settings.local.json # Personal project settings (gitignore)

{
  "model": "claude-sonnet-4-6",
  "alwaysThinkingEnabled": true,
  "permissions": {
    "allow": ["Read", "Write", "Bash(git *)", "Bash(npm *)"],
    "deny": ["Bash(rm -rf *)", "Write(.env*)"]
  },
  "env": {
    "NODE_ENV": "development",
    "LOG_LEVEL": "debug"
  },
  "hooks": {
    "PreToolUse": [...],
    "PostToolUse": [...]
  }
}

your-project/
├── CLAUDE.md                    # Shared project instructions (commit this)
├── CLAUDE.local.md              # Personal instructions (gitignore)
├── .mcp.json                    # MCP server configs (commit this)
└── .claude/
    ├── settings.json            # Shared settings (commit this)
    ├── settings.local.json      # Personal settings (gitignore)
    ├── commands/                # Custom slash commands
    │   ├── pr.md
    │   ├── review.md
    │   └── deploy.md
    ├── agents/                  # Sub-agent definitions
    │   ├── security-auditor.md
    │   └── test-writer.md
    ├── skills/                  # Auto-activated expertise
    │   └── python-typing/
    │       └── SKILL.md
    └── hooks/                   # Hook scripts
        ├── pre-commit-check.sh
        └── block-env-writes.sh

{
  "permissions": {
    "allow": [
      "Read",
      "Write",
      "Bash(git *)",
      "Bash(npm run *)",
      "Bash(pytest *)",
      "Bash(docker-compose *)"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(sudo *)",
      "Write(.env*)",
      "Write(**/migrations/**)"
    ]
  }
}

# Allow specific tools without dialog
claude --allowedTools "Read" "Write" "Bash(git *)"

# Deny specific tools entirely
claude --disallowedTools "Write"

# Via CLI (wizard)
claude mcp add github -- npx -y @modelcontextprotocol/server-github

# With environment variables
claude mcp add github -s user \
  -e GITHUB_PERSONAL_ACCESS_TOKEN=your-token \
  -- npx -y @modelcontextprotocol/server-github

# View installed servers
claude mcp list

{
  "mcpServers": {
    "github": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token"
      }
    },
    "postgres": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://localhost/mydb"
      }
    },
    "sequential-thinking": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}

/mcp__github__create_issue
/mcp__github__search_repositories
/mcp__filesystem__read_file
/mcp__memory__create_entities

{
  "matcher": "mcp__github__.*",   // Match all GitHub MCP tools
  "hooks": [...]
}

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash(git commit*)",
        "hooks": [
          {
            "type": "command",
            "command": "bash .claude/hooks/pre-commit-check.sh"
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "bash .claude/hooks/run-linter.sh"
          }
        ]
      }
    ]
  }
}

#!/bin/bash
# .claude/hooks/pre-commit-check.sh

# Run tests
npm run test 2>&1

if [ $? -ne 0 ]; then
  echo '{"decision": "block", "reason": "Tests must pass before committing"}'
  exit 0
fi

# Tests passed — allow commit
echo '{"decision": "allow"}'

#!/bin/bash
# .claude/hooks/block-dangerous.sh

INPUT=$(cat)
COMMAND=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin)['tool_input'].get('command',''))")

# Block rm -rf
if echo "$COMMAND" | grep -qE "rm\s+-rf\s+/"; then
  echo '{"decision": "block", "reason": "Refusing to delete system directories"}'
  exit 0
fi

echo '{"decision": "allow"}'

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'INPUT=$(cat); FILE=$(echo $INPUT | python3 -c \"import sys,json; print(json.load(sys.stdin)[\\\"tool_input\\\"][\\\"path\\\"]\"); if [[ $FILE == *.env* ]]; then echo \\'{{\"decision\":\"block\",\"reason\":\"Cannot write to .env files\"}}\\'; else echo \\'{{\"decision\":\"allow\"}}\\'; fi'"
          }
        ]
      }
    ]
  }
}

# Project-specific command
mkdir -p .claude/commands
echo "Review this code for security vulnerabilities, focusing on OWASP Top 10:" \
  > .claude/commands/security-review.md

# Global command (all projects)
mkdir -p ~/.claude/commands
echo "Write comprehensive tests for the selected code:" \
  > ~/.claude/commands/write-tests.md

<!-- .claude/commands/fix-issue.md -->

Fix GitHub issue #$ARGUMENTS following our coding standards in CLAUDE.md.

Steps:

1. Read the issue description
2. Identify affected files
3. Implement the fix with tests
4. Run the test suite
5. Create a descriptive commit message

# Usage in session
/fix-issue 342

<!-- .claude/commands/pr.md -->

Create a pull request for the current changes.

Steps:

1. Run `git diff` to understand all changes
2. Run the full test suite — abort if any fail
3. Write a clear PR description explaining WHY, not just what
4. Create the PR with appropriate labels
5. Request review from the relevant team members based on the files changed

/help   # Lists all built-in AND custom commands

## <!-- .claude/agents/security-auditor.md -->

name: security-auditor
description: Specialized in application security analysis and vulnerability assessment
allowed-tools: Read, Grep, Glob, Bash(git log:_), Bash(git diff:_)

---

# Security Auditor Agent

You are a senior application security engineer specializing in:

## Expertise

- OWASP Top 10 vulnerabilities
- SQL injection, XSS, CSRF patterns
- Authentication and authorization flaws
- Secrets and credential exposure
- Dependency vulnerability analysis

## Response Format

Always provide:

1. Severity rating (Critical/High/Medium/Low)
2. Affected files and line numbers
3. Proof of concept or explanation
4. Concrete remediation steps
5. References (CVE, OWASP, etc.)

## <!-- .claude/agents/test-writer.md -->

name: test-writer
description: Writes comprehensive tests for new or modified code
allowed-tools: Read, Write, Bash(pytest _), Bash(npm test _)

---

You are a test engineering specialist. For every function or component:

- Write unit tests covering happy path, edge cases, and error conditions
- Follow existing test patterns in the codebase
- Aim for >90% branch coverage
- Use descriptive test names that explain what's being tested

## <!-- .claude/agents/db-expert.md -->

name: db-expert
description: Database query optimization, schema design, and migration planning
allowed-tools: Read, Bash(psql _), mcp**postgres**._

---

You are a database architect expert focused on:

- Query performance and indexing strategy
- Schema normalization and design
- Safe migration planning
- Analyze EXPLAIN ANALYZE output
  Always provide performance impact estimates.

# In a session, just refer to the agent by name
claude --agent security-auditor "audit the authentication module"

# Or Claude will automatically delegate when appropriate
"Use the security-auditor agent to review all API endpoints"

.claude/skills/
└── python-typing/
    ├── SKILL.md         # Description + instructions
    └── examples/        # Optional example files

## <!-- .claude/skills/python-typing/SKILL.md -->

name: python-typing
description: Adding or improving Python type hints and type annotations in Python code

---

When adding type hints to Python code:

1. Use `from __future__ import annotations` for forward references
2. Prefer `X | Y` over `Optional[X]` or `Union[X, Y]` (Python 3.10+)
3. Use `TypeAlias` for complex type aliases
4. Add `Protocol` for structural subtyping
5. Annotate all function signatures including return types
6. Use `TypeVar` for generic functions
7. Add `py.typed` marker file if it's a library

Always run `mypy --strict` after adding type hints to verify correctness.

my-plugin/
├── plugin.json          # Plugin manifest
├── commands/
│   └── security-check.md
├── hooks/
│   └── pre-commit.sh
├── skills/
│   └── security/
│       └── SKILL.md
└── mcp/
    └── config.json

# Via npm (if published)
npm install -g claude-code-plugin-security

# Or directly from GitHub
claude plugin install https://github.com/user/my-plugin

/context   # Shows used / total tokens, percentage

/compact                                    # Summarize everything
/compact retain the error handling patterns # Keep specific things
/compact retain all API endpoints discovered so far

# Resume a previous session
claude --resume

# Continue most recent
claude -c

# Advanced: analyze session logs for patterns
ls ~/.claude/projects/my-project/

SHIFT + TAB    # Cycle through modes in session
--permission-mode plan    # Start in plan mode

claude --remote "Add dark mode to the settings page"

# .github/workflows/claude-agent.yml
name: Claude Code Agent

on:
  issues:
    types: [labeled]

jobs:
  fix-issue:
    if: github.event.label.name == 'claude-fix'
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "20"

      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code

      - name: Run Claude Code Agent
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          claude -p "
            Fix GitHub issue #${{ github.event.issue.number }}: 
            ${{ github.event.issue.title }}
            
            Issue body: ${{ github.event.issue.body }}
            
            Steps:
            1. Understand the issue
            2. Identify the root cause
            3. Implement the fix with tests
            4. Verify tests pass
            5. Create a pull request
          " \
          --allowedTools "Read,Write,Bash(git *),Bash(npm *)" \
          --max-turns 20

# PreToolUse hook on git commit — check tests passed first
# This is better than blocking on every Edit/Write operation

# Use Haiku for cheap, fast exploration tasks
claude --model haiku "find all files that import from auth module"

# Use Sonnet for most production tasks (best balance)
claude --model sonnet "refactor the payment service"

# Use Opus only for very complex reasoning
claude --model opus "design the new event sourcing architecture"

claude -p "..." \
  --output-format json \
  --max-turns 15 2>&1 | tee agent_log_$(date +%Y%m%d).json

# Analyze what other Claude instances got stuck on, then fix it
cat ~/.claude/projects/*/logs/*.json | \
  claude -p "see what the other Claude sessions got stuck on and improve our CLAUDE.md"

# 1. Explicitly deny dangerous operations
{
  "permissions": {
    "deny": ["Bash(rm -rf *)", "Bash(sudo *)", "Write(.env*)"]
  }
}

# 2. Use --allowedTools in CI/CD to whitelist only what's needed
claude -p "..." --allowedTools "Read,Grep,Glob"

# 3. Never use --dangerously-skip-permissions in any shared environment

# 4. Audit installed MCP servers regularly
claude mcp list

# 5. Scope MCP permissions — not every server needs Write access

{
  "permissions": {
    "deny": ["Read(.env*)", "Write(.env*)", "Read(**/.env*)"]
  }
}

claude                          # New session
claude "task"                   # New session with prompt
claude -p "task"                # One-shot, exit when done
claude -c                       # Continue last session
claude --resume                 # Pick session to resume
claude --model sonnet           # Set model
claude --allowedTools "Read,Write"   # Pre-approve tools
claude --permission-mode plan   # Plan-only mode
claude --append-system-prompt "..."  # Add to system prompt
claude --agent MyAgent          # Use specific sub-agent
claude --worktree feature-x     # Isolated git worktree

SHIFT+TAB    → cycle modes
ESC          → cancel generation
ESC+ESC      → undo last action
CTRL+B       → background task
CTRL+O       → verbose toggle
/compact     → summarize + clear
/clear       → clear context
/model       → switch model
/context     → check usage %
/mcp         → manage MCP servers
/permissions → update permissions

CLAUDE.md                     → project instructions (commit)
CLAUDE.local.md               → personal instructions (gitignore)
.claude/settings.json         → shared settings (commit)
.claude/settings.local.json   → personal settings (gitignore)
.mcp.json                     → MCP servers (commit)
.claude/commands/             → custom slash commands
.claude/agents/               → sub-agent definitions
.claude/skills/               → auto-activated skills
.claude/hooks/                → hook scripts
~/.claude/CLAUDE.md           → global instructions (all projects)

< 70%  → work freely
70-90% → /compact now
90%+   → /clear mandatory
switching tasks → /clear

mcp__<server>__<tool>
mcp__github__create_issue
mcp__postgres__query
mcp__filesystem__read_file

claude-opus-4-6         # Opus 4
claude-sonnet-4-6       # Sonnet 4 (most common in production)
claude-haiku-4-5-20251001  # Haiku 4

Need deep reasoning or complex analysis? → Opus
Building a production app with real users? → Sonnet (default choice)
High-volume, classification, simple Q&A? → Haiku
Streaming chatbot, real-time features? → Haiku or Sonnet

pip install -U langchain-anthropic langgraph

from langchain_anthropic import ChatAnthropic

llm = ChatAnthropic(
    model="claude-sonnet-4-6",
    # api_key="sk-ant-..."  # or set ANTHROPIC_API_KEY env var
    max_tokens=1024
)

# Modern style: pass tuples directly — no need to import message classes
messages = [
    ("system", "You are a senior Python engineer."),
    ("human", "Explain async/await in Python"),
]

response = llm.invoke(messages)
print(response.content)

from langchain_anthropic import ChatAnthropic
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import START, MessagesState, StateGraph

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=512)

# Build a minimal stateful graph
def call_model(state: MessagesState):
    response = llm.invoke(state["messages"])
    return {"messages": response}

workflow = StateGraph(state_schema=MessagesState)
workflow.add_edge(START, "model")
workflow.add_node("model", call_model)

app = workflow.compile(checkpointer=MemorySaver())

# Each invocation with the same thread_id shares memory
config = {"configurable": {"thread_id": "user-1"}}

# Turn 1
app.invoke({"messages": [("human", "My name is Alex")]}, config=config)

# Turn 2 — Claude remembers Alex
result = app.invoke({"messages": [("human", "What's my name?")]}, config=config)
print(result["messages"][-1].content)

from langchain_core.prompts import ChatPromptTemplate
from langchain_anthropic import ChatAnthropic

prompt = ChatPromptTemplate.from_messages([
    ("system", """
<role>You are a senior data engineer at a fintech company.</role>
<constraints>
  - Focus only on indexing and query plan issues
  - Return your answer in JSON format
  - Do not suggest schema changes
</constraints>
"""),
    ("human", """
<task>Analyze the SQL query below and identify performance bottlenecks.</task>
<query>{query}</query>
""")
])

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=1024)
chain = prompt | llm

response = chain.invoke({"query": "SELECT * FROM transactions WHERE user_id = 123 ORDER BY created_at DESC;"})
print(response.content)

from langchain_core.prompts import FewShotChatMessagePromptTemplate, ChatPromptTemplate
from langchain_anthropic import ChatAnthropic

examples = [
    {"input": "gonna grab some coffee real quick",
     "output": "I will briefly step away to get some coffee."},
    {"input": "can u fix this bug asap",
     "output": "Could you please resolve this bug at your earliest convenience?"},
]

example_prompt = ChatPromptTemplate.from_messages([
    ("human", "{input}"),
    ("ai", "{output}"),
])

few_shot_prompt = FewShotChatMessagePromptTemplate(
    example_prompt=example_prompt,
    examples=examples,
)

final_prompt = ChatPromptTemplate.from_messages([
    ("system", "Convert each sentence to formal English."),
    few_shot_prompt,
    ("human", "{input}"),
])

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=256)
chain = final_prompt | llm
response = chain.invoke({"input": "lemme know when ur done"})
print(response.content)

from langchain_core.prompts import ChatPromptTemplate
from langchain_anthropic import ChatAnthropic

prompt = ChatPromptTemplate.from_messages([
    ("human", """
Solve this problem step by step, showing your reasoning at each stage.

Problem: {problem}
""")
])

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=1024)
chain = prompt | llm

response = chain.invoke({
    "problem": "A train travels 120km at 60km/h, then 80km at 40km/h. What is the average speed?"
})
print(response.content)

from langchain_anthropic import ChatAnthropic
from pydantic import BaseModel

class ExtractedData(BaseModel):
    name: str
    email: str | None
    sentiment: str   # "positive" | "negative" | "neutral"
    priority: int    # 1-5

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=512)
structured_llm = llm.with_structured_output(ExtractedData)

result = structured_llm.invoke(
    "Hi, I'm Sarah (sarah@email.com). I'm very frustrated with the billing issue and need this fixed ASAP."
)
print(result.name)       # Sarah
print(result.sentiment)  # negative
print(result.priority)   # 5

from typing_extensions import Annotated
from langchain_anthropic import ChatAnthropic

def get_weather(
    city: Annotated[str, "The city name, e.g. 'Sydney' or 'New York'"],
    unit: Annotated[str, "Temperature unit: 'celsius' or 'fahrenheit'"] = "celsius",
) -> str:
    """Get current weather for a specific city."""
    return f"The weather in {city} is 22°{unit[0].upper()} and sunny."

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=1024)
llm_with_tools = llm.bind_tools([get_weather])

response = llm_with_tools.invoke("What's the weather in Sydney?")
print(response.tool_calls)

llm_with_tools = llm.bind_tools([get_weather], strict=True)
# Requires langchain-anthropic>=1.1.0 and Claude Sonnet 4.5+ or Opus 4.1+

from langchain_anthropic import ChatAnthropic
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent

@tool
def get_weather(city: str) -> str:
    """Get current weather for a city."""
    return f"22°C and sunny in {city}"

@tool
def search_web(query: str) -> str:
    """Search the web for current information."""
    return f"Search results for: {query}"

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=1024)
agent = create_react_agent(llm, tools=[get_weather, search_web])

result = agent.invoke({"messages": [("user", "What's the weather in Sydney?")]})
print(result["messages"][-1].content)

from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage

llm = ChatAnthropic(
    model="claude-opus-4-6",   # Works best on Opus
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": 10000}
)

response = llm.invoke([
    HumanMessage(content="Prove that the square root of 2 is irrational.")
])

# Response content may contain thinking blocks
for block in response.content:
    if isinstance(block, dict):
        if block.get("type") == "thinking":
            print("CLAUDE'S REASONING:\n", block["thinking"])
        elif block.get("type") == "text":
            print("FINAL ANSWER:\n", block["text"])

import base64
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage

with open("chart.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode("utf-8")

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=1024)

message = HumanMessage(content=[
    {
        "type": "image_url",
        "image_url": {"url": f"data:image/png;base64,{image_data}"}
    },
    {
        "type": "text",
        "text": "Describe what's in this chart and identify the trend."
    }
])

response = llm.invoke([message])
print(response.content)

import base64
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage

with open("report.pdf", "rb") as f:
    pdf_data = base64.b64encode(f.read()).decode("utf-8")

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=2048)

message = HumanMessage(content=[
    {
        "type": "document",
        "source": {
            "type": "base64",
            "media_type": "application/pdf",
            "data": pdf_data
        }
    },
    {"type": "text", "text": "Summarize the key findings from this report."}
])

response = llm.invoke([message])
print(response.content)

from langchain_anthropic import ChatAnthropic
from langchain_core.messages import SystemMessage, HumanMessage

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=1024)

# Mark large system prompt for caching using extra_headers or beta flag
# LangChain passes cache_control through the `additional_kwargs` on messages

system_msg = SystemMessage(
    content=[{
        "type": "text",
        "text": "You are an expert on our 500-page company policy document.\n[... very long content ...]",
        "cache_control": {"type": "ephemeral"}   # ← Mark for caching
    }]
)

response = llm.invoke([
    system_msg,
    HumanMessage(content="What is our vacation policy?")
])
print(response.content)

200,000 tokens ≈ 150,000 words ≈ ~400 pages of text

from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import START, MessagesState, StateGraph

# LangGraph automatically trims/manages history via the checkpointer
app = workflow.compile(checkpointer=MemorySaver())

from langchain_core.messages import trim_messages

def call_model(state: MessagesState):
    trimmed = trim_messages(state["messages"], max_tokens=4000, token_counter=llm)
    response = llm.invoke(trimmed)
    return {"messages": response}

from langchain_core.prompts import ChatPromptTemplate

summarize_prompt = ChatPromptTemplate.from_messages([
    ("human", """
Summarize the following conversation into bullet points,
preserving all key facts, decisions, and user preferences:

{conversation}
""")
])

summary_chain = summarize_prompt | llm
summary = summary_chain.invoke({"conversation": old_conversation_text})

from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_community.vectorstores import FAISS
from langchain_anthropic import AnthropicEmbeddings  # or use OpenAI embeddings

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=1024)

# Build retriever from your documents
vectorstore = FAISS.load_local("my_index", embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 5})

prompt = ChatPromptTemplate.from_messages([
    ("system", """You are a helpful assistant. Answer questions based ONLY on the
provided context. If the answer isn't in the context, say "I don't have that information."
Always cite which part of the context you used."""),
    ("human", """
<context>
{context}
</context>

<question>
{question}
</question>
""")
])

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
)

response = rag_chain.invoke("What is our vacation policy?")
print(response.content)

from langchain_anthropic import ChatAnthropic

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=1024)

for chunk in llm.stream([("human", "Write a short story about a robot.")]):
    print(chunk.text, end="", flush=True)

async for chunk in llm.astream([("human", "Tell me a joke.")]):
    print(chunk.text, end="", flush=True)

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([("human", "{input}")])
chain = prompt | llm

for chunk in chain.stream({"input": "Tell me a joke."}):
    print(chunk.text, end="", flush=True)

from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=512)

docs = ["Summary of doc 1...", "Summary of doc 2...", "Summary of doc 3..."]
messages_batch = [[HumanMessage(content=f"Summarize: {doc}")] for doc in docs]

results = llm.batch(messages_batch)
for r in results:
    print(r.content)

import anthropic
import time

client = anthropic.Anthropic()

batch = client.messages.batches.create(
    requests=[
        {
            "custom_id": f"doc-{i:03d}",
            "params": {
                "model": "claude-sonnet-4-6",
                "max_tokens": 512,
                "messages": [{"role": "user", "content": f"Summarize: {doc}"}]
            }
        }
        for i, doc in enumerate(docs)
    ]
)

# Poll until complete
while True:
    batch = client.messages.batches.retrieve(batch.id)
    if batch.processing_status == "ended":
        break
    time.sleep(60)

for result in client.messages.batches.results(batch.id):
    print(f"{result.custom_id}: {result.result.message.content[0].text}")

npm install -g @anthropic-ai/claude-code
claude  # Start a session

claude                          # Start new session
claude "fix the login bug"      # Start with initial prompt
claude -p "explain this code"   # One-shot query, then exit
claude -c                       # Continue most recent session
claude --model opus             # Use specific model
claude --allowedTools "Read" "Write"   # Skip permission dialogs for these
claude --dangerously-skip-permissions  # Skip ALL permission dialogs (careful!)

# Project: E-Commerce API

## Stack

- Python 3.12 + FastAPI
- PostgreSQL with SQLAlchemy ORM
- Redis for caching

## Conventions

- All endpoints must have type hints
- Use snake_case for variable names
- Write tests for every new function in /tests

## DO NOT

- Modify .env files
- Delete migration files
- Change database schema without asking first

Claude Client (Claude.ai / Claude Code / Your App)
        ↕ MCP Protocol
MCP Server (exposes tools + resources)
        ↕
External Service (GitHub, Slack, Databases, APIs...)

from langchain_anthropic import ChatAnthropic
from langgraph.prebuilt import create_react_agent

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=1000)

# Attach remote MCP servers directly to the model
llm_with_mcp = llm.bind_tools([{
    "type": "mcp",
    "server_label": "github",
    "server_url": "https://github.mcp.server/sse",
    "headers": {"Authorization": "Bearer your-token"},
    "allowed_tools": ["create_issue", "search_repositories"],
}])

response = llm_with_mcp.invoke(
    "Create a GitHub issue for the login bug we discussed"
)
print(response.content)

# pip install langchain-mcp-adapters
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent

async def run_mcp_agent():
    async with MultiServerMCPClient({
        "github": {
            "command": "npx",
            "args": ["-y", "@modelcontextprotocol/server-github"],
            "env": {"GITHUB_PERSONAL_ACCESS_TOKEN": "your-token"},
            "transport": "stdio",
        }
    }) as client:
        tools = client.get_tools()
        llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=1000)
        agent = create_react_agent(llm, tools)
        result = await agent.ainvoke({
            "messages": [("user", "Create a GitHub issue for the login bug")]
        })
        print(result["messages"][-1].content)

from langchain_anthropic import ChatAnthropic
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=4096)

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

@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 to {path}"

@tool
def run_tests() -> str:
    """Run the test suite."""
    import subprocess
    result = subprocess.run(["pytest", "-v"], capture_output=True, text=True)
    return result.stdout + result.stderr

agent = create_react_agent(llm, tools=[read_file, write_file, run_tests])
result = agent.invoke({"messages": [("user", "Fix the failing tests in test_auth.py")]})
print(result["messages"][-1].content)

from langchain_anthropic import ChatAnthropic

# Use different models for different agent roles
research_llm = ChatAnthropic(model="claude-haiku-4-5-20251001", max_tokens=1024)   # Fast, cheap
code_llm     = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=4096)           # Balanced
review_llm   = ChatAnthropic(model="claude-opus-4-6", max_tokens=2048)             # Thorough

# Wire into a LangGraph multi-agent workflow
# (see LangGraph docs for full multi-agent patterns)

# Bad — vague, triggers caution
llm.invoke("Help me hack into a system")

# Good — clear professional context
from langchain_core.messages import SystemMessage, HumanMessage

llm.invoke([
    SystemMessage(content="You are a security engineer assistant supporting authorized penetration testing."),
    HumanMessage(content="""
I'm doing an authorized penetration test on our own infrastructure.
I need to understand common SQL injection patterns to test our input validation.
Please show examples with explanations.
""")
])

from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=1024)

prompt = ChatPromptTemplate.from_messages([
    ("system", """
You are a customer support agent for AcmeCorp.

STRICT RULES:
- Only answer questions about AcmeCorp products
- Never discuss competitors
- If asked about anything outside scope, say:
  "I can only help with AcmeCorp product questions."
- If the user becomes abusive, respond once with a warning then end the conversation politely
"""),
    ("human", "{user_input}")
])

chain = prompt | llm

from langchain_anthropic import ChatAnthropic

# Built-in: retries automatically on rate limits and transient errors
llm = ChatAnthropic(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    max_retries=3,      # default is 2 (mirrors Anthropic SDK default)
    timeout=60,
)

import anthropic

llm_with_retry = llm.with_retry(
    retry_if_exception_type=(anthropic.RateLimitError,),
    stop_after_attempt=3
)

from langchain_anthropic import ChatAnthropic
from pydantic import BaseModel, field_validator

class ExtractedData(BaseModel):
    name: str
    email: str | None
    sentiment: str
    priority: int

    @field_validator("priority")
    def priority_range(cls, v):
        assert 1 <= v <= 5, "Priority must be 1-5"
        return v

llm = ChatAnthropic(model="claude-sonnet-4-6", max_tokens=512)
structured_llm = llm.with_structured_output(ExtractedData)

result = structured_llm.invoke(
    "Hi, I'm Sarah (sarah@email.com). I'm frustrated with billing and need this fixed ASAP."
)
print(result)  # ExtractedData(name='Sarah', email='sarah@email.com', ...)

# .env
ANTHROPIC_API_KEY=sk-ant-...

# Load in Python
from dotenv import load_dotenv
load_dotenv()

from langchain_anthropic import ChatAnthropic
llm = ChatAnthropic(model="claude-sonnet-4-6")  # Picks up ANTHROPIC_API_KEY automatically

# Rough calculation
input_tokens = 1000
output_tokens = 500
sonnet_cost = (input_tokens * 3 + output_tokens * 15) / 1_000_000
# ≈ $0.0105 per call

Install:    pip install langchain-anthropic langchain-core
Models:     Opus > Sonnet > Haiku (capability vs speed/cost)
Context:    200K tokens (~150K words)
Init:       ChatAnthropic(model="claude-sonnet-4-6")
Invoke:     llm.invoke([HumanMessage(content="...")])
Stream:     for chunk in llm.stream([...]): print(chunk.content)
Batch:      llm.batch([[HumanMessage(...)], [...]])
Tools:      llm.bind_tools([my_tool])
Structured: llm.with_structured_output(MyPydanticModel)
Retry:      llm.with_retry(stop_after_attempt=3)
Chain:      prompt | llm | output_parser
Agent:      create_react_agent(llm, tools=[...])
Thinking:   ChatAnthropic(..., thinking={"type": "enabled", "budget_tokens": N})
Caching:    Add "cache_control": {"type": "ephemeral"} to message content blocks