Claude

# Example of using Claude Opus 4.5 for complex refactoring
import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-opus-4-5-20251101",
    max_tokens=8192,
    messages=[
        {
            "role": "user",
            "content": """Analyze the following code and propose comprehensive
            refactoring considering SOLID principles, design patterns
            and TypeScript best practices:

            [code to analyze]"""
        }
    ]
)

print(message.content[0].text)

// Example of Claude Sonnet integration with Next.js application
import Anthropic from '@anthropic-ai/sdk'

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY!
})

export async function POST(request: Request) {
  const { message, conversationHistory } = await request.json()

  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-5-20241022',
    max_tokens: 4096,
    system: `You are a helpful programming assistant.
             Always respond in English.`,
    messages: [
      ...conversationHistory,
      { role: 'user', content: message }
    ]
  })

  return Response.json({
    reply: response.content[0].text,
    usage: response.usage
  })
}

# Example batch processing with Claude Haiku
import anthropic
import asyncio

client = anthropic.Anthropic()

async def classify_support_ticket(ticket: str) -> dict:
    message = client.messages.create(
        model="claude-3-haiku-20240307",
        max_tokens=100,
        messages=[
            {
                "role": "user",
                "content": f"""Classify the following support ticket.
                Return JSON with fields: category, priority, sentiment.

                Ticket: {ticket}"""
            }
        ]
    )
    return {"classification": message.content[0].text}

# Processing multiple tickets in parallel
async def process_tickets(tickets: list[str]):
    tasks = [classify_support_ticket(t) for t in tickets]
    return await asyncio.gather(*tasks)

# SDK Installation
pip install anthropic  # Python
npm install @anthropic-ai/sdk  # JavaScript/TypeScript

# Basic API call in Python
import anthropic

client = anthropic.Anthropic(
    api_key="your-api-key"  # Or set ANTHROPIC_API_KEY
)

message = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain what React is in 3 sentences."}
    ]
)

print(message.content[0].text)

// Basic API call in TypeScript
import Anthropic from '@anthropic-ai/sdk'

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY
})

const message = await anthropic.messages.create({
  model: 'claude-sonnet-4-5-20241022',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'Explain what React is in 3 sentences.' }
  ]
})

console.log(message.content[0].text)

message = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    max_tokens=1024,
    system="""You are an experienced software architect with 15 years
    of experience. You specialize in:
    - Designing distributed systems
    - Microservices and event-driven architecture
    - Performance optimization

    You answer concisely, with code examples and ASCII diagrams
    where helpful. You always consider trade-offs of different solutions.""",
    messages=[
        {"role": "user", "content": "How to design a notification system for 1M users?"}
    ]
)

import Anthropic from '@anthropic-ai/sdk'

const anthropic = new Anthropic()

// Streaming in TypeScript
const stream = await anthropic.messages.stream({
  model: 'claude-sonnet-4-5-20241022',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'Write a tutorial about React Hooks' }
  ]
})

for await (const event of stream) {
  if (event.type === 'content_block_delta' &&
      event.delta.type === 'text_delta') {
    process.stdout.write(event.delta.text)
  }
}

# Streaming in Python
with client.messages.stream(
    model="claude-sonnet-4-5-20241022",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Write a tutorial about React Hooks"}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

import base64

# Load image
with open("screenshot.png", "rb") as f:
    image_data = base64.standard_b64encode(f.read()).decode("utf-8")

message = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": image_data
                    }
                },
                {
                    "type": "text",
                    "text": "What do you see in this screenshot? Identify all UI elements."
                }
            ]
        }
    ]
)

tools = [
    {
        "name": "get_weather",
        "description": "Gets current weather for a given city",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "City name"
                },
                "units": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Temperature unit"
                }
            },
            "required": ["city"]
        }
    },
    {
        "name": "search_database",
        "description": "Searches the product database",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "category": {"type": "string"},
                "max_results": {"type": "integer", "default": 10}
            },
            "required": ["query"]
        }
    }
]

message = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    max_tokens=1024,
    tools=tools,
    messages=[
        {"role": "user", "content": "What's the weather in New York?"}
    ]
)

# Claude will respond with tool_use if it decides to use a tool
for block in message.content:
    if block.type == "tool_use":
        print(f"Tool: {block.name}")
        print(f"Input: {block.input}")

# Mark parts of prompt for caching
message = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "You are a programming assistant...",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": large_code_context,  # Large code context
                    "cache_control": {"type": "ephemeral"}
                },
                {
                    "type": "text",
                    "text": "Find potential bugs in this code."
                }
            ]
        }
    ]
)

# Create batch request
batch = client.batches.create(
    requests=[
        {
            "custom_id": "request-1",
            "params": {
                "model": "claude-sonnet-4-5-20241022",
                "max_tokens": 1024,
                "messages": [
                    {"role": "user", "content": "Question 1..."}
                ]
            }
        },
        {
            "custom_id": "request-2",
            "params": {
                "model": "claude-sonnet-4-5-20241022",
                "max_tokens": 1024,
                "messages": [
                    {"role": "user", "content": "Question 2..."}
                ]
            }
        }
    ]
)

# Check status
status = client.batches.retrieve(batch.id)
print(f"Status: {status.processing_status}")

# Get results when ready
if status.processing_status == "ended":
    results = client.batches.results(batch.id)
    for result in results:
        print(f"{result.custom_id}: {result.result.message.content[0].text}")

# macOS / Linux
curl -fsSL https://claude.ai/install.sh | sh

# npm (alternative)
npm install -g @anthropic-ai/claude-code

# Verify installation
claude --version

# Start interactive session
claude

# Pass task as argument
claude "Refactor the function in utils.ts file"

# Continue previous session
claude --continue

# Non-interactive mode (pipe)
cat error.log | claude "Analyze these errors and propose fixes"

# Claude Code can:

# 1. Read and edit files
claude "Add form validation to components/LoginForm.tsx"

# 2. Run terminal commands
claude "Install and configure ESLint with TypeScript"

# 3. Create new projects
claude "Create a new Next.js project with Tailwind, Prisma and NextAuth"

# 4. Debug problems
claude "Why aren't the tests in jest.config.js working?"

# 5. Refactor code
claude "Convert this class component to functional with hooks"

# 6. Generate documentation
claude "Add JSDoc to all functions in src/utils/"

# Project: E-commerce Platform

## Stack
- Next.js 14 App Router
- TypeScript (strict mode)
- Prisma + PostgreSQL
- TailwindCSS
- Stripe for payments

## Conventions
- Use functional components with hooks
- Prefer server components where possible
- Keep components under 200 lines
- Write tests for all business logic

## Directory Structure
- app/ - Next.js App Router pages
- components/ - Reusable UI components
- lib/ - Utilities and helpers
- prisma/ - Database schema and migrations

## Commands
- npm run dev - Start development server
- npm run test - Run tests
- npm run db:migrate - Run database migrations

# Scenario: Adding a new feature

$ claude
╭─────────────────────────────────────────────╮
│ Claude Code v1.0.0                          │
│ Working in: /projects/my-app                │
╰─────────────────────────────────────────────╯

You: Add a Stripe payment handling API endpoint

Claude: I'll analyze the current project structure and add
the payment endpoint. I'll perform the following steps:

1. Check if Stripe is installed
2. Create API endpoint in app/api/payments/route.ts
3. Add TypeScript types
4. Create helper function for webhook verification

[Executing: npm list stripe]
[Creating: app/api/payments/route.ts]
[Creating: lib/stripe.ts]
[Updating: .env.example]

Done! Here's what was added:
- app/api/payments/route.ts - POST endpoint for session creation
- lib/stripe.ts - Stripe client configuration
- Added STRIPE_SECRET_KEY and STRIPE_WEBHOOK_SECRET to .env.example

Would you like me to add webhook handling as well?

pip install anthropic-agent-sdk

from anthropic_agent import Agent, Tool, Memory

# Define tools for the agent
class FileReadTool(Tool):
    name = "read_file"
    description = "Reads file contents"

    def run(self, path: str) -> str:
        with open(path, 'r') as f:
            return f.read()

class FileWriteTool(Tool):
    name = "write_file"
    description = "Writes content to file"

    def run(self, path: str, content: str) -> str:
        with open(path, 'w') as f:
            f.write(content)
        return f"Saved to {path}"

class ShellTool(Tool):
    name = "shell"
    description = "Executes shell command"

    def run(self, command: str) -> str:
        import subprocess
        result = subprocess.run(
            command, shell=True, capture_output=True, text=True
        )
        return result.stdout + result.stderr

# Create agent
agent = Agent(
    model="claude-sonnet-4-5-20241022",
    tools=[FileReadTool(), FileWriteTool(), ShellTool()],
    memory=Memory(max_tokens=100000),
    system_prompt="""You are an experienced Python developer.
    Your task is to help with project development.
    Always test your changes before reporting."""
)

# Run agent
result = agent.run(
    "Add a new /api/users endpoint to the Flask app in app.py"
)
print(result)

from anthropic_agent import Agent, PersistentMemory

# Memory preserved between sessions
memory = PersistentMemory(
    storage_path="./agent_memory",
    max_entries=1000
)

agent = Agent(
    model="claude-sonnet-4-5-20241022",
    memory=memory,
    tools=[...],
    system_prompt="You are a project assistant. Remember previous sessions."
)

# Agent remembers previous interactions
agent.run("Continue working on the feature we started yesterday")

# ❌ Too general
"Write sorting code"

# ✅ Detailed
"""Write a TypeScript function that:
- Sorts an array of User objects by 'createdAt' field (Date)
- Handles both ascending and descending order
- Is efficient for arrays up to 10000 elements
- Has full TypeScript types
- Includes Jest unit tests"""

prompt = """
# Task
Analyze the following code for security vulnerabilities.

# Code to analyze
```python
def login(username, password):
    query = f"SELECT * FROM users WHERE username='{username}' AND password='{password}'"
    return db.execute(query)

3. **Give examples (Few-shot prompting)**

```python
prompt = """
Transform descriptions into JSON format.

Example 1:
Input: "John Smith, 35 years old, programmer from London"
Output: {"name": "John Smith", "age": 35, "occupation": "programmer", "city": "London"}

Example 2:
Input: "Anna Brown, 28 years old, doctor from Manchester"
Output: {"name": "Anna Brown", "age": 28, "occupation": "doctor", "city": "Manchester"}

Now transform:
Input: "Peter Johnson, 42 years old, architect from Edinburgh"
Output:"""

prompt = """
Solve this problem step by step, explaining your reasoning.

Problem: We have an API endpoint that sometimes returns error 500.
Logs show "Connection refused" to Redis database.
Redis runs on the same server.
Error only occurs during peak hours (12-14).

Analyze possible causes and propose solutions.
Show your reasoning before each conclusion.
"""

system_prompt = """You are a Staff Engineer at a FAANG company with 15 years
of experience. You specialize in:
- Distributed systems
- High-performance computing
- Mentoring juniors

Your communication style:
- Concrete and to the point
- Uses analogies to explain complex concepts
- Always mentions trade-offs
- Gives practical production examples"""

prompt = """
<context>
You're working on an e-commerce application in Next.js.
Stack: Next.js 14, Prisma, PostgreSQL, Stripe.
</context>

<current_code>
// components/Cart.tsx
export function Cart({ items }) {
  return (
    <div>
      {items.map(item => <CartItem key={item.id} {...item} />)}
    </div>
  )
}
</current_code>

<task>
Add functionality:
1. Calculate total sum
2. "Proceed to checkout" button
3. Empty cart handling
</task>

<constraints>
- Use TypeScript with full types
- Component should be server component where possible
- Styling in Tailwind CSS
</constraints>
"""

# First prompt
response1 = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    messages=[
        {"role": "user", "content": "Write an email validation function"}
    ]
)

# Iteration with feedback
response2 = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    messages=[
        {"role": "user", "content": "Write an email validation function"},
        {"role": "assistant", "content": response1.content[0].text},
        {"role": "user", "content": """Great! Now:
        1. Add subdomain support
        2. Also validate local-part length (max 64 characters)
        3. Add tests for edge cases"""}
    ]
)

// app/api/chat/route.ts
import Anthropic from '@anthropic-ai/sdk'
import { NextResponse } from 'next/server'

const anthropic = new Anthropic()

export async function POST(request: Request) {
  const { messages, systemPrompt } = await request.json()

  try {
    const response = await anthropic.messages.create({
      model: 'claude-sonnet-4-5-20241022',
      max_tokens: 4096,
      system: systemPrompt || 'You are a helpful assistant.',
      messages: messages.map((m: any) => ({
        role: m.role,
        content: m.content
      }))
    })

    return NextResponse.json({
      message: response.content[0].text,
      usage: response.usage
    })
  } catch (error) {
    console.error('Claude API error:', error)
    return NextResponse.json(
      { error: 'AI communication error' },
      { status: 500 }
    )
  }
}

// components/ChatInterface.tsx
'use client'

import { useState } from 'react'

interface Message {
  role: 'user' | 'assistant'
  content: string
}

export function ChatInterface() {
  const [messages, setMessages] = useState<Message[]>([])
  const [input, setInput] = useState('')
  const [isLoading, setIsLoading] = useState(false)

  const sendMessage = async () => {
    if (!input.trim()) return

    const userMessage: Message = { role: 'user', content: input }
    setMessages(prev => [...prev, userMessage])
    setInput('')
    setIsLoading(true)

    try {
      const response = await fetch('/api/chat', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          messages: [...messages, userMessage]
        })
      })

      const data = await response.json()

      setMessages(prev => [
        ...prev,
        { role: 'assistant', content: data.message }
      ])
    } catch (error) {
      console.error('Error:', error)
    } finally {
      setIsLoading(false)
    }
  }

  return (
    <div className="flex flex-col h-screen max-w-2xl mx-auto">
      <div className="flex-1 overflow-y-auto p-4 space-y-4">
        {messages.map((message, index) => (
          <div
            key={index}
            className={`p-4 rounded-lg ${
              message.role === 'user'
                ? 'bg-blue-100 ml-8'
                : 'bg-gray-100 mr-8'
            }`}
          >
            {message.content}
          </div>
        ))}
        {isLoading && (
          <div className="bg-gray-100 p-4 rounded-lg mr-8 animate-pulse">
            Thinking...
          </div>
        )}
      </div>

      <div className="p-4 border-t">
        <div className="flex gap-2">
          <input
            type="text"
            value={input}
            onChange={(e) => setInput(e.target.value)}
            onKeyPress={(e) => e.key === 'Enter' && sendMessage()}
            placeholder="Type a message..."
            className="flex-1 p-2 border rounded-lg"
            disabled={isLoading}
          />
          <button
            onClick={sendMessage}
            disabled={isLoading}
            className="px-4 py-2 bg-blue-500 text-white rounded-lg
                     hover:bg-blue-600 disabled:opacity-50"
          >
            Send
          </button>
        </div>
      </div>
    </div>
  )
}

// app/api/chat/stream/route.ts
import Anthropic from '@anthropic-ai/sdk'

const anthropic = new Anthropic()

export async function POST(request: Request) {
  const { messages } = await request.json()

  const stream = await anthropic.messages.stream({
    model: 'claude-sonnet-4-5-20241022',
    max_tokens: 4096,
    messages
  })

  const encoder = new TextEncoder()

  const readable = new ReadableStream({
    async start(controller) {
      for await (const event of stream) {
        if (event.type === 'content_block_delta' &&
            event.delta.type === 'text_delta') {
          controller.enqueue(
            encoder.encode(`data: ${JSON.stringify({ text: event.delta.text })}\n\n`)
          )
        }
      }
      controller.enqueue(encoder.encode('data: [DONE]\n\n'))
      controller.close()
    }
  })

  return new Response(readable, {
    headers: {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache',
      'Connection': 'keep-alive'
    }
  })
}

from anthropic import Anthropic
import chromadb
from sentence_transformers import SentenceTransformer

# Initialization
client = Anthropic()
chroma = chromadb.Client()
collection = chroma.create_collection("docs")
embedder = SentenceTransformer('all-MiniLM-L6-v2')

def add_documents(documents: list[str]):
    """Add documents to vector database"""
    embeddings = embedder.encode(documents).tolist()
    collection.add(
        embeddings=embeddings,
        documents=documents,
        ids=[f"doc_{i}" for i in range(len(documents))]
    )

def query_with_rag(question: str) -> str:
    """Answer question using RAG"""
    # 1. Find relevant documents
    query_embedding = embedder.encode([question]).tolist()
    results = collection.query(
        query_embeddings=query_embedding,
        n_results=3
    )

    context = "\n\n".join(results['documents'][0])

    # 2. Generate answer with context
    message = client.messages.create(
        model="claude-sonnet-4-5-20241022",
        max_tokens=2048,
        system="""Answer questions based on provided context.
        If the context doesn't contain the answer, say so explicitly.""",
        messages=[
            {
                "role": "user",
                "content": f"""Context:
{context}

Question: {question}

Answer:"""
            }
        ]
    )

    return message.content[0].text

# Usage
add_documents([
    "Next.js 14 introduces App Router with Server Components...",
    "Prisma is a modern ORM for TypeScript and Node.js...",
    "TailwindCSS allows utility-first styling..."
])

answer = query_with_rag("How does App Router work in Next.js?")
print(answer)

import anthropic
from anthropic import APIError, RateLimitError, APIConnectionError

client = anthropic.Anthropic()

def safe_call(messages: list, retries: int = 3):
    for attempt in range(retries):
        try:
            response = client.messages.create(
                model="claude-sonnet-4-5-20241022",
                max_tokens=1024,
                messages=messages
            )
            return response
        except RateLimitError:
            if attempt < retries - 1:
                import time
                time.sleep(2 ** attempt)  # Exponential backoff
                continue
            raise
        except APIConnectionError as e:
            print(f"Connection error: {e}")
            raise
        except APIError as e:
            print(f"API error: {e}")
            raise

# 1. Never put API key in code
import os
api_key = os.environ.get("ANTHROPIC_API_KEY")

# 2. Validate user input
def sanitize_input(user_input: str) -> str:
    # Limit length
    if len(user_input) > 10000:
        raise ValueError("Input too long")

    # Remove potentially dangerous content
    # (prompt injection prevention)
    return user_input.strip()

# 3. Limit output
message = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    max_tokens=1000,  # Always set a limit
    messages=[...]
)

# 4. Monitor usage
print(f"Tokens used: {message.usage.input_tokens + message.usage.output_tokens}")

# 5. Implement rate limiting in your application
from functools import lru_cache
import time

last_call_time = {}

def rate_limited_call(user_id: str, messages: list):
    now = time.time()
    if user_id in last_call_time:
        elapsed = now - last_call_time[user_id]
        if elapsed < 1:  # 1 request per second per user
            time.sleep(1 - elapsed)

    last_call_time[user_id] = time.time()
    return client.messages.create(...)