name: cloud-api-invocation description: | Generate Python code for invoking Claude in cloud/remote environments using Anthropic's Messages API. Handles API authentication, SDK setup, basic/multi-turn conversations, model selection, and tool use/function calling patterns. Trigger keywords: Anthropic API, Claude API, Messages API, invoke Claude programmatically, Claude SDK, remote Claude, cloud Claude execution, API integration, programmatic tool calling, function calling, tool use API, Python SDK license: Apache-2.0 compatibility: Requires Python 3.8+, anthropic SDK, network access to api.anthropic.com metadata: author: Claude Agent SDK version: "1.0.0" allowed-tools: Bash Read Write Edit

Cloud API Invocation Skill

Overview

This skill generates ready-to-use Python code for invoking Claude via Anthropic's Messages API in cloud and remote environments. It produces complete, working code snippets that users can copy and run immediately, covering API authentication, SDK setup, message handling, streaming responses, and tool use patterns.

Instructions

Follow this workflow when generating API integration code:

1. Identify the integration need: Determine what the user wants - basic API call, streaming, tool use, multi-turn conversation, or error handling
2. Select the appropriate pattern: Choose from the code generation patterns below based on the user's requirements
3. Generate complete code: Include all imports, client setup, API calls, and response handling
4. Add error handling: Include try/except blocks for common errors (missing API key, rate limits, network issues)
5. Include comments: Add clear comments explaining each section of the generated code
6. Provide run instructions: Show how to install dependencies and run the generated code

Usage Examples

Example 1: Basic API Call

User Request: "How do I call the Claude API?"

Generated Code:

import anthropic
import os

# Initialize the Anthropic client (uses ANTHROPIC_API_KEY env var by default)
client = anthropic.Anthropic()

# Make a basic API call
message = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Claude! What can you help me with today?"}
    ]
)

# Extract and print the response text
print(message.content[0].text)

Example 2: Streaming Response

User Request: "Generate code for streaming Claude responses"

Generated Code:

import anthropic

client = anthropic.Anthropic()

# Use streaming for real-time response output
with client.messages.stream(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explain quantum computing in simple terms."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

print()  # Newline after streaming completes

Example 3: Tool Use / Function Calling

User Request: "How do I use tool calling with Claude API?"

Generated Code:

import anthropic
import json

client = anthropic.Anthropic()

# Define tools that Claude can call
tools = [
    {
        "name": "get_weather",
        "description": "Get the current weather for a location",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {"type": "string", "description": "City and state, e.g. San Francisco, CA"},
                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"], "default": "fahrenheit"}
            },
            "required": ["location"]
        }
    }
]

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

# Handle tool use response
for block in response.content:
    if block.type == "tool_use":
        print(f"Tool called: {block.name}")
        print(f"Input: {json.dumps(block.input, indent=2)}")
    elif block.type == "text":
        print(f"Response: {block.text}")

Example 4: Multi-turn Conversation

User Request: "Create an API integration with conversation history"

Generated Code:

import anthropic

client = anthropic.Anthropic()

# Maintain conversation history
conversation_history = []

def chat(user_message: str) -> str:
    """Send a message and get a response, maintaining conversation context."""
    conversation_history.append({"role": "user", "content": user_message})

    response = client.messages.create(
        model="claude-sonnet-4-5-20250929",
        max_tokens=1024,
        system="You are a helpful assistant.",
        messages=conversation_history
    )

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

    return assistant_message

# Example conversation
print(chat("My name is Alice."))
print(chat("What's my name?"))  # Claude remembers context

Code Generation Patterns

Pattern 1: Basic API Call with Environment Setup

import anthropic
import os

# Verify API key is set
if not os.environ.get("ANTHROPIC_API_KEY"):
    raise ValueError("ANTHROPIC_API_KEY environment variable is not set")

# Initialize client
client = anthropic.Anthropic()

# Create message with all common parameters
message = client.messages.create(
    model="claude-sonnet-4-5-20250929",  # or claude-opus-4-5-20251101, claude-haiku-4-5
    max_tokens=1024,
    temperature=0.7,  # Optional: 0.0-1.0, lower = more deterministic
    system="You are a helpful coding assistant.",  # Optional system prompt
    messages=[
        {"role": "user", "content": "Write a Python function to reverse a string."}
    ]
)

# Response handling
print(f"Response: {message.content[0].text}")
print(f"Stop reason: {message.stop_reason}")  # end_turn, max_tokens, tool_use
print(f"Usage: {message.usage.input_tokens} input, {message.usage.output_tokens} output tokens")

Pattern 2: Streaming with Event Handling

import anthropic

client = anthropic.Anthropic()

# Streaming with full event access
with client.messages.stream(
    model="claude-sonnet-4-5-20250929",
    max_tokens=2048,
    messages=[{"role": "user", "content": "Write a short story about a robot."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

# Get final message after streaming completes
final_message = stream.get_final_message()
print(f"\n\nTotal tokens: {final_message.usage.input_tokens + final_message.usage.output_tokens}")

Pattern 3: Complete Tool Use Flow

import anthropic
import json

client = anthropic.Anthropic()

def execute_tool(name: str, input_data: dict) -> str:
    """Execute a tool and return the result. Implement your tool logic here."""
    if name == "calculator":
        expression = input_data.get("expression", "")
        try:
            result = eval(expression)  # In production, use a safe math parser
            return json.dumps({"result": result})
        except Exception as e:
            return json.dumps({"error": str(e)})
    return json.dumps({"error": f"Unknown tool: {name}"})

tools = [
    {
        "name": "calculator",
        "description": "Evaluate mathematical expressions",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {"type": "string", "description": "Math expression to evaluate"}
            },
            "required": ["expression"]
        }
    }
]

messages = [{"role": "user", "content": "What is 25 * 47 + 123?"}]

# Initial request
response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    tools=tools,
    messages=messages
)

# Handle tool use loop
while response.stop_reason == "tool_use":
    # Process tool calls
    tool_results = []
    for block in response.content:
        if block.type == "tool_use":
            result = execute_tool(block.name, block.input)
            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": result
            })

    # Continue conversation with tool results
    messages.append({"role": "assistant", "content": response.content})
    messages.append({"role": "user", "content": tool_results})

    response = client.messages.create(
        model="claude-sonnet-4-5-20250929",
        max_tokens=1024,
        tools=tools,
        messages=messages
    )

# Print final response
for block in response.content:
    if hasattr(block, "text"):
        print(block.text)

Pattern 4: Error Handling with Exponential Backoff

import anthropic
import time
import random

client = anthropic.Anthropic()

def call_with_retry(messages: list, max_retries: int = 5) -> anthropic.types.Message:
    """Make an API call with exponential backoff for rate limits."""
    for attempt in range(max_retries):
        try:
            return client.messages.create(
                model="claude-sonnet-4-5-20250929",
                max_tokens=1024,
                messages=messages
            )
        except anthropic.RateLimitError as e:
            if attempt == max_retries - 1:
                raise
            wait_time = (2 ** attempt) + random.uniform(0, 1)
            print(f"Rate limited. Waiting {wait_time:.2f}s before retry...")
            time.sleep(wait_time)
        except anthropic.APIConnectionError as e:
            print(f"Connection error: {e}. Retrying...")
            time.sleep(1)
        except anthropic.AuthenticationError as e:
            raise ValueError(f"Invalid API key: {e}")

    raise Exception("Max retries exceeded")

# Usage
response = call_with_retry([{"role": "user", "content": "Hello!"}])
print(response.content[0].text)

Pattern 5: Programmatic Tool Calling (Beta)

import anthropic

client = anthropic.Anthropic()

# Define a tool with programmatic calling enabled (beta feature)
tools = [
    {
        "name": "code_executor",
        "description": "Execute Python code safely",
        "input_schema": {
            "type": "object",
            "properties": {
                "code": {"type": "string", "description": "Python code to execute"}
            },
            "required": ["code"]
        },
        "allowed_callers": ["user", "tool"]  # Beta: allows programmatic invocation
    }
]

# Use beta flag for advanced tool features
response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    tools=tools,
    betas=["advanced-tool-use-2025-11-20"],
    messages=[{"role": "user", "content": "Run some Python code to calculate fibonacci(10)"}]
)

for block in response.content:
    if block.type == "tool_use":
        print(f"Tool: {block.name}, Input: {block.input}")

Guidelines

When generating API integration code, follow these guidelines:

• Always include imports: Start every code block with necessary imports (import anthropic, import os, etc.)
• Use environment variables for API keys: Never hardcode API keys; use os.environ.get("ANTHROPIC_API_KEY")
• Include error handling: Add try/except blocks for AuthenticationError, RateLimitError, and APIConnectionError
• Use latest model IDs: Prefer claude-sonnet-4-5-20250929 for balanced performance, claude-opus-4-5-20251101 for complex tasks
• Set appropriate max_tokens: Default to 1024; increase for longer responses (max 8192 for most models)
• Add helpful comments: Explain what each section does, especially for tool definitions and response handling
• Handle stop_reason values: Check for end_turn (normal), max_tokens (truncated), tool_use (tool call needed)
• Show complete examples: Every code snippet should be runnable as-is after setting the API key

Common Patterns

SDK Installation

pip install anthropic

API Key Setup

export ANTHROPIC_API_KEY="your-api-key-here"

Model Selection Guide

| Model | Use Case | Model ID | |-------|----------|----------| | Sonnet | Balanced performance/cost | claude-sonnet-4-5-20250929 | | Opus | Complex reasoning tasks | claude-opus-4-5-20251101 | | Haiku | Fast, simple tasks | claude-haiku-4-5 |

Common Parameters

client.messages.create(
    model="claude-sonnet-4-5-20250929",  # Required: model to use
    max_tokens=1024,                      # Required: max output tokens
    messages=[...],                       # Required: conversation messages
    system="...",                         # Optional: system prompt
    temperature=0.7,                      # Optional: 0.0-1.0 randomness
    tools=[...],                          # Optional: tool definitions
    stop_sequences=["END"],               # Optional: stop generation triggers
)

Edge Cases

• Missing API key: Check for ANTHROPIC_API_KEY before creating client; raise clear error with setup instructions
• Rate limit (429) errors: Implement exponential backoff starting at 1 second, max 5 retries
• Network timeout: Set reasonable timeout, catch APIConnectionError, retry with backoff
• Invalid model name: Validate model ID against known models; suggest alternatives if invalid
• Tool use with no tools defined: If stop_reason is tool_use but no tools provided, handle gracefully
• Empty response content: Check len(message.content) > 0 before accessing content[0]
• Max tokens exceeded: If stop_reason is max_tokens, warn user response may be truncated

References

• Anthropic Messages API Documentation
• Python SDK GitHub Repository
• Tool Use Documentation
• Rate Limits and Tiers

Limitations

• Requires a valid Anthropic API key with appropriate permissions
• Subject to rate limits based on account tier (Tier 1: 50 RPM, Tier 4: 4000 RPM)
• Beta features like programmatic tool calling may change without notice
• Network connectivity to api.anthropic.com is required
• Maximum context window varies by model (check documentation for current limits)
• Generated code examples use Python; TypeScript/JavaScript patterns differ slightly