Claude AI Complete Guide — Features and API

Example: Uploading a codebase for analysis

1. Go to claude.ai
2. Create a new conversation
3. Click the attachment icon
4. Upload your main source files or a zipped archive
5. Ask questions like: "Analyze this codebase for security issues"
6. Claude analyzes the files and responds

# Install the Python SDK
pip install anthropic

# Set API key
export ANTHROPIC_API_KEY="sk-ant-..."

from anthropic import Anthropic

client = Anthropic()

# Simple request
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Explain quantum computing in simple terms"
        }
    ]
)

print(response.content[0].text)

from anthropic import Anthropic

client = Anthropic()
conversation_history = []

def chat(user_message):
    """Send a message and get response"""
    conversation_history.append({
        "role": "user",
        "content": user_message
    })

    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        system="""You are a helpful coding assistant.
Provide practical, working examples. Explain your reasoning.""",
        messages=conversation_history
    )

    assistant_message = response.content[0].text
    conversation_history.append({
        "role": "assistant",
        "content": assistant_message
    })

    return assistant_message

# Multi-turn conversation
print(chat("What's the best way to validate email addresses in Python?"))
print(chat("Can you show me a regex pattern for that?"))
print(chat("How do I test that regex?"))

import anthropic
import base64

client = anthropic.Anthropic()

# Method 1: Analyze a text file
def analyze_code_file(file_path):
    with open(file_path, 'r') as f:
        code = f.read()

    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=2000,
        messages=[
            {
                "role": "user",
                "content": f"Review this code for security issues:\n\n{code}"
            }
        ]
    )

    return response.content[0].text

# Method 2: Analyze an image
def analyze_image(image_path):
    with open(image_path, 'rb') as f:
        image_data = base64.standard_b64encode(f.read()).decode('utf-8')

    # Determine media type
    if image_path.endswith('.png'):
        media_type = "image/png"
    elif image_path.endswith('.jpg'):
        media_type = "image/jpeg"
    else:
        media_type = "image/webp"

    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "image",
                        "source": {
                            "type": "base64",
                            "media_type": media_type,
                            "data": image_data
                        }
                    },
                    {
                        "type": "text",
                        "text": "What's shown in this screenshot? Any issues or improvements?"
                    }
                ]
            }
        ]
    )

    return response.content[0].text

# Usage
print(analyze_code_file("app.py"))
print(analyze_image("screenshot.png"))

def analyze_large_codebase(file_paths):
    """Analyze entire codebase within context"""
    client = anthropic.Anthropic()

    # Compile all code
    content = "Repository Structure Analysis\n\n"

    for file_path in file_paths:
        with open(file_path, 'r') as f:
            code = f.read()
        content += f"\n\n{'='*50}\nFile: {file_path}\n{'='*50}\n{code}"

    # Single request to analyze entire repo
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=4000,
        messages=[
            {
                "role": "user",
                "content": f"{content}\n\nAnalyze this codebase for:\n1. Architecture and design\n2. Security issues\n3. Performance bottlenecks\n4. Refactoring opportunities\n5. Test coverage gaps"
            }
        ]
    )

    return response.content[0].text

# Analyze 20+ source files in one request
files = ["src/main.py", "src/utils.py", "src/models.py", ...]
analysis = analyze_large_codebase(files)

# Use Haiku for simple tasks
def use_appropriate_model(task_type):
    if task_type == "simple_completion":
        return "claude-3-5-haiku-20241022"  # Fast and cheap
    elif task_type == "code_review":
        return "claude-3-5-sonnet-20241022"  # Good balance
    else:
        return "claude-3-opus-20250219"  # Maximum capability

# Control output length
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=500,  # Limit response length
    messages=[...]
)

# Cache repeated system prompts
system_prompt = "You are a code review expert..."
# Use the same system prompt across multiple requests

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    tools=[
        {
            "name": "get_weather",
            "description": "Get current weather",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {"type": "string"}
                },
                "required": ["location"]
            }
        }
    ],
    messages=[
        {"role": "user", "content": "What's the weather in NYC?"}
    ]
)

# Handle tool calls in response
for content_block in response.content:
    if content_block.type == "tool_use":
        tool_name = content_block.name
        tool_input = content_block.input
        # Execute tool and return results

import anthropic
import json

client = anthropic.Anthropic()

# Create batch requests
requests = [
    {
        "custom_id": "task_1",
        "params": {
            "model": "claude-3-5-sonnet-20241022",
            "max_tokens": 1024,
            "messages": [
                {"role": "user", "content": "Task 1 content"}
            ]
        }
    },
    {
        "custom_id": "task_2",
        "params": {
            "model": "claude-3-5-sonnet-20241022",
            "max_tokens": 1024,
            "messages": [
                {"role": "user", "content": "Task 2 content"}
            ]
        }
    }
]

# Submit batch (typically cheaper than individual requests)
batch = client.beta.batch_processing.submit(requests)

from slack_sdk import WebClient
import anthropic

def respond_to_slack_message(message_text):
    client = anthropic.Anthropic()

    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=500,
        messages=[
            {"role": "user", "content": message_text}
        ]
    )

    return response.content[0].text

# Persistent conversation with Claude
class ChatSession:
    def __init__(self):
        self.client = anthropic.Anthropic()
        self.messages = []

    def send_message(self, user_message):
        self.messages.append({
            "role": "user",
            "content": user_message
        })

        response = self.client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1024,
            system="You are a helpful assistant.",
            messages=self.messages
        )

        assistant_message = response.content[0].text
        self.messages.append({
            "role": "assistant",
            "content": assistant_message
        })

        return assistant_message