Claude AI Setup Guide

# Your API key will look like this:
sk-ant-api03-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

pip install anthropic

import anthropic

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

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain AI agents in simple terms."}
    ]
)

print(message.content[0].text)

npm install @anthropic-ai/sdk

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

async function main() {
  const message = await client.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 1024,
    messages: [
      { role: "user", content: "Explain AI agents in simple terms." }
    ],
  });

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

main();

curl https://api.anthropic.com/v1/messages \
  -H "Content-Type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Explain AI agents in simple terms."}
    ]
  }'

Settings → Team → Members
├── Invite by email (individual or bulk)
├── Set roles (Admin, Member, Viewer)
├── Configure permissions
└── Set usage limits per user

Marketing Project
├── Campaign brainstorming
├── Copy reviews
├── Competitor analysis
└── Shared knowledge base

Development Project
├── Code reviews
├── Architecture discussions
├── Documentation drafts
└── Technical specifications

<!-- Example SAML Configuration -->
<EntityDescriptor entityID="https://claude.ai/sso/saml">
  <SPSSODescriptor>
    <AssertionConsumerService
      Location="https://claude.ai/api/auth/saml/callback"
      Binding="urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST"/>
  </SPSSODescriptor>
</EntityDescriptor>

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="""You are an expert business analyst specializing in SaaS metrics.

    Guidelines:
    - Provide data-driven insights
    - Use industry benchmarks when relevant
    - Be concise but thorough
    - Ask clarifying questions when data is ambiguous
    - Format numerical data in tables when comparing metrics""",
    messages=[
        {"role": "user", "content": "Analyze this MRR trend: Jan $50k, Feb $52k, Mar $48k, Apr $55k"}
    ]
)

system_prompt = """Analyze the provided text and return JSON in this exact format:
{
  "sentiment": "positive" | "negative" | "neutral",
  "confidence": 0.0 to 1.0,
  "key_topics": ["topic1", "topic2"],
  "action_items": ["action1", "action2"],
  "summary": "2-3 sentence summary"
}

Return ONLY valid JSON, no additional text."""

Analyze whether we should expand into the European market.

Think through this systematically:
1. First, identify the key factors to consider
2. Analyze each factor with available data
3. Consider potential risks and mitigation strategies
4. Evaluate resource requirements
5. Provide a recommendation with confidence level

Show your reasoning at each step.

Convert customer feedback into structured tickets.

Example 1:
Input: "Your app crashes every time I try to upload a file larger than 10MB"
Output:
- Type: Bug
- Priority: High
- Component: File Upload
- Summary: App crashes on files >10MB
- Steps: 1. Open app 2. Navigate to upload 3. Select file >10MB 4. App crashes

Example 2:
Input: "Would be great if you could add dark mode"
Output:
- Type: Feature Request
- Priority: Medium
- Component: UI/UX
- Summary: Add dark mode theme option
- Steps: N/A

Now convert this feedback:
Input: "The search is so slow, takes like 30 seconds to find anything"

import anthropic
import base64

def analyze_image(image_path: str, question: str) -> str:
    with open(image_path, "rb") as f:
        image_data = base64.standard_b64encode(f.read()).decode("utf-8")

    client = anthropic.Anthropic()

    message = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "image",
                        "source": {
                            "type": "base64",
                            "media_type": "image/png",
                            "data": image_data,
                        },
                    },
                    {
                        "type": "text",
                        "text": question
                    }
                ],
            }
        ],
    )

    return message.content[0].text

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a location",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City and country, e.g., 'London, UK'"
                }
            },
            "required": ["location"]
        }
    }
]

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

# Claude will request to use the get_weather tool
# Your code calls the actual API and returns results

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

class SupportAgent:
    def __init__(self):
        self.client = anthropic.Anthropic()
        self.system_prompt = """You are a customer support agent for [Company].

        Guidelines:
        - Be empathetic and professional
        - If you can solve the issue, provide clear steps
        - If you cannot solve it, escalate to human support
        - Never make up information about policies or features
        - Always verify account details before making changes"""

    def handle_ticket(self, ticket: dict) -> dict:
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            system=self.system_prompt,
            messages=[
                {"role": "user", "content": f"""
                Customer: {ticket['customer_name']}
                Issue: {ticket['description']}
                Category: {ticket['category']}
                Previous Interactions: {ticket.get('history', 'None')}

                Provide a response and recommended action.
                """}
            ]
        )

        return {
            "response": response.content[0].text,
            "requires_human": self._check_escalation(response)
        }

class ContentPipeline:
    def __init__(self):
        self.client = anthropic.Anthropic()

    def generate_blog_post(self, topic: str, keywords: list) -> dict:
        # Step 1: Generate outline
        outline = self._generate_outline(topic, keywords)

        # Step 2: Write sections
        sections = []
        for section in outline['sections']:
            content = self._write_section(section, topic)
            sections.append(content)

        # Step 3: Generate metadata
        metadata = self._generate_metadata(topic, sections)

        return {
            "title": outline['title'],
            "sections": sections,
            "metadata": metadata
        }

    def _generate_outline(self, topic: str, keywords: list) -> dict:
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            system="Generate SEO-optimized blog post outlines.",
            messages=[{"role": "user", "content": f"""
                Topic: {topic}
                Target Keywords: {', '.join(keywords)}

                Create an outline with:
                - Compelling title (include primary keyword)
                - 5-7 main sections with H2 headings
                - Key points for each section

                Return as JSON.
            """}]
        )
        return json.loads(response.content[0].text)

# NEVER do this:
client = anthropic.Anthropic(api_key="sk-ant-api03-xxx")

# DO this instead:
import os
client = anthropic.Anthropic()  # Uses ANTHROPIC_API_KEY env var

# Or use a secrets manager:
from your_secrets_manager import get_secret
client = anthropic.Anthropic(api_key=get_secret("anthropic-api-key"))

def validate_user_input(user_input: str) -> str:
    # Limit input length
    if len(user_input) > 10000:
        raise ValueError("Input too long")

    # Remove potential injection attempts
    # (Claude is resistant, but defense in depth)
    sanitized = user_input.replace("ignore previous instructions", "[filtered]")

    return sanitized

import logging

def monitored_request(prompt: str) -> str:
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{"role": "user", "content": prompt}]
    )

    # Log for audit
    logging.info(f"Claude request: prompt_length={len(prompt)}, "
                 f"response_length={len(response.content[0].text)}, "
                 f"tokens_used={response.usage.input_tokens + response.usage.output_tokens}")

    # Check for sensitive content in response
    if contains_sensitive_data(response.content[0].text):
        logging.warning("Response may contain sensitive data")
        return "[Response filtered for review]"

    return response.content[0].text

import time
from anthropic import RateLimitError

def request_with_retry(prompt: str, max_retries: int = 3) -> str:
    for attempt in range(max_retries):
        try:
            response = client.messages.create(...)
            return response.content[0].text
        except RateLimitError:
            wait_time = (2 ** attempt) * 1  # Exponential backoff
            time.sleep(wait_time)
    raise Exception("Max retries exceeded")

def chunk_long_content(content: str, max_tokens: int = 100000) -> list:
    # Approximate: 1 token ≈ 4 characters
    max_chars = max_tokens * 4
    chunks = []

    while content:
        chunks.append(content[:max_chars])
        content = content[max_chars:]

    return chunks