import anthropic

client = anthropic.Anthropic(api_key="your-api-key")

message = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Explain the difference between REST and GraphQL."
        }
    ]
)

print(message.content[0].text)

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=2048,
    system="You are a helpful coding assistant. Be concise.",
    messages=[
        {"role": "user", "content": "How do I reverse a string in Python?"},
        {"role": "assistant", "content": "You can use slicing: `s[::-1]`"},
        {"role": "user", "content": "What about in JavaScript?"}
    ]
)

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

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

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "image",
                "source": {
                    "type": "base64",
                    "media_type": "image/png",
                    "data": image_data,
                }
            },
            {"type": "text", "text": "Describe this architecture diagram"}
        ]
    }]
)

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a location",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City name or coordinates"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"]
                }
            },
            "required": ["location"]
        }
    }
]

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

# Claude returns a tool_use block when it wants to call a function
if response.stop_reason == "tool_use":
    tool_call = response.content[0]
    # Execute the actual function with tool_call.input
    weather_result = get_weather(**tool_call.input)
    # Feed result back to Claude

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # Let Claude think up to 10K tokens
    },
    messages=[{
        "role": "user",
        "content": "Analyze the pros and cons of microservices vs. monolithic architecture for a 5-person startup building a marketplace app"
    }]
)

# Access the thinking trace
for block in response.content:
    if block.type == "thinking":
        print("Reasoning:", block.thinking[:500], "...")
    elif block.type == "text":
        print("Answer:", block.text)

system = """You are a senior software engineer specializing in Python and cloud architecture.

When answering questions:
- Always include code examples
- Mention time/space complexity for algorithms
- Flag potential security or performance issues
- Keep responses under 500 words unless asked for detail"""

prompt = """
<context>
We have a PostgreSQL database with 10 million rows in a users table.
Query: SELECT * FROM users WHERE email = ?
Current response time: 3.2 seconds
</context>

<task>
Diagnose the performance issue and provide specific optimization steps.
</task>
"""

prompt = """
Analyze this business problem step by step:
1. First, identify all stakeholders
2. Then, list potential solutions
3. Evaluate each solution against criteria: cost, time, risk
4. Finally, recommend the best approach with reasoning

Problem: [Your problem here]
"""

import anthropic
import time
from anthropic import RateLimitError, APIStatusError

def call_with_retry(client, **kwargs, max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.messages.create(**kwargs)
        except RateLimitError:
            wait_time = 2 ** attempt
            time.sleep(wait_time)
    raise Exception("Max retries exceeded")

response = client.messages.create(...)
input_tokens = response.usage.input_tokens
output_tokens = response.usage.output_tokens

# Claude Sonnet 4.5 pricing
cost = (input_tokens * 3 + output_tokens * 15) / 1_000_000
print(f"Request cost: ${cost:.6f}")

def trim_conversation(messages, max_tokens=150_000):
    """Keep conversation within token limits"""
    # Always keep system message and recent turns
    # Summarize or remove older messages
    total = sum(estimate_tokens(m) for m in messages)
    while total > max_tokens and len(messages) > 2:
        messages.pop(1)  # Remove oldest user message
        total = sum(estimate_tokens(m) for m in messages)
    return messages

system = "You are a friendly customer support agent for AcmeCo. Use the knowledge base to answer questions accurately."

# Knowledge base via long context
full_docs = load_support_documentation()  # Up to 200K tokens!
messages = [{"role": "user", "content": f"{full_docs}\n\nCustomer: {user_query}"}]

def review_pull_request(pr_diff: str) -> dict:
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=2048,
        system="You are an expert code reviewer. Focus on: bugs, security, performance, readability.",
        messages=[{"role": "user", "content": f"Review this PR:\n```\n{pr_diff}\n```"}]
    )
    return {"review": response.content[0].text, "tokens": response.usage.output_tokens}