Anthropic API - Claude Safe and Reliable AI API Service

pip install anthropic

import anthropic

# Initialize client (replace with your API key)
client = anthropic.Anthropic(
    api_key="your-api-key-here"
)

# Send request
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Hello, please introduce the main features of Claude API."
        }
    ]
)

# Print response
print(response.content[0].text)

# View token usage
print(f"\nInput Tokens: {response.usage.input_tokens}")
print(f"Output Tokens: {response.usage.output_tokens}")

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=2048,
    system="You are a professional Python programming assistant, skilled at code optimization and best practices.",
    messages=[
        {
            "role": "user",
            "content": """Please optimize this code:

def find_max(arr):
    max_val = arr[0]
    for i in range(len(arr)):
        if arr[i] > max_val:
            max_val = arr[i]
    return max_val
"""
        }
    ]
)

print(response.content[0].text)

# Streaming output (suitable for real-time display)
with client.messages.stream(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Write a poem about AI"
        }
    ]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

curl https://api.anthropic.com/v1/messages \
  -H "Content-Type: application/json" \
  -H "x-api-key: your-api-key-here" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-3-5-sonnet-20241022",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Hello, please introduce Claude API."
      }
    ]
  }'

curl https://api.anthropic.com/v1/messages \
  -H "Content-Type: application/json" \
  -H "x-api-key: your-api-key-here" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-3-5-sonnet-20241022",
    "max_tokens": 1024,
    "system": "You are a professional technical consultant.",
    "messages": [
      {
        "role": "user",
        "content": "What is microservices architecture?"
      }
    ]
  }'

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

const client = new Anthropic({
  apiKey: 'your-api-key-here',
});

async function main() {
  const message = await client.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 1024,
    messages: [
      {
        role: 'user',
        content: 'Hello, please introduce the main features of Claude API.'
      }
    ],
  });

  console.log(message.content[0].text);
  console.log(`\nInput Tokens: ${message.usage.input_tokens}`);
  console.log(`Output Tokens: ${message.usage.output_tokens}`);
}

main();

import time
from anthropic import Anthropic, APIError, RateLimitError

client = Anthropic(api_key="your-api-key-here")

def call_api_with_retry(messages, max_retries=3):
    """API call with retry mechanism"""
    for attempt in range(max_retries):
        try:
            response = client.messages.create(
                model="claude-3-5-sonnet-20241022",
                max_tokens=1024,
                messages=messages
            )
            return response
        except RateLimitError:
            wait_time = 2 ** attempt
            print(f"Rate limit reached, waiting {wait_time} seconds...")
            time.sleep(wait_time)
        except APIError as e:
            print(f"API error: {e}")
            if attempt == max_retries - 1:
                raise
    
    return None

# Usage example
messages = [{"role": "user", "content": "Hello"}]
response = call_api_with_retry(messages)
if response:
    print(response.content[0].text)

def calculate_cost(input_tokens, output_tokens, model="claude-3-5-sonnet"):
    """Calculate API call cost"""
    pricing = {
        "claude-3-5-sonnet": {"input": 3, "output": 15},
        "claude-3-opus": {"input": 15, "output": 75},
        "claude-3-haiku": {"input": 0.25, "output": 1.25}
    }
    
    price = pricing.get(model, pricing["claude-3-5-sonnet"])
    cost = (input_tokens * price["input"] + output_tokens * price["output"]) / 1_000_000
    
    return cost

# Usage example
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}]
)

cost = calculate_cost(
    response.usage.input_tokens,
    response.usage.output_tokens
)
print(f"Cost for this call: ${cost:.6f}")

def analyze_long_document(document_path):
    """Analyze long documents"""
    with open(document_path, 'r', encoding='utf-8') as f:
        document = f.read()
    
    client = Anthropic(api_key="your-api-key-here")
    
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=4096,
        system="You are a professional document analysis expert.",
        messages=[
            {
                "role": "user",
                "content": f"""Please analyze the following technical document:

{document}

Please provide:
1. Document content overview
2. Key technical points
3. Important conclusions and recommendations
4. Potential issues and risks"""
            }
        ]
    )
    
    return response.content[0].text

# Usage example
result = analyze_long_document("technical_spec.txt")
print(result)

def code_review(code, language="python"):
    """Code review assistant"""
    client = Anthropic(api_key="your-api-key-here")
    
    prompt = f"""Please review the following {language} code:

{code}

Please provide:
1. Code quality assessment
2. Potential bugs or issues
3. Performance optimization suggestions
4. Best practice recommendations
5. Security checks"""
    
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=2048,
        system=f"You are a senior {language} developer expert, skilled in code review and optimization.",
        messages=[
            {
                "role": "user",
                "content": prompt
            }
        ]
    )
    
    return response.content[0].text

# Usage example
code = """
def process_data(data):
    result = []
    for item in data:
        if item > 0:
            result.append(item * 2)
    return result
"""

review = code_review(code)
print(review)

class CustomerServiceBot:
    def __init__(self, api_key, knowledge_base):
        self.client = Anthropic(api_key=api_key)
        self.knowledge_base = knowledge_base
        self.conversation_history = []
    
    def chat(self, user_message):
        """Handle user messages"""
        # Add user message to history
        self.conversation_history.append({
            "role": "user",
            "content": user_message
        })
        
        # Call API
        response = self.client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1024,
            system=f"""You are a professional customer service assistant.

Knowledge base:
{self.knowledge_base}

Please answer user questions based on the knowledge base, maintaining politeness and professionalism.""",
            messages=self.conversation_history
        )
        
        assistant_message = response.content[0].text
        
        # Add assistant response to history
        self.conversation_history.append({
            "role": "assistant",
            "content": assistant_message
        })
        
        return assistant_message

# Usage example
knowledge = """
Product: Smart Watch X1
Price: $299
Features: Health monitoring, activity tracking, message notifications
Warranty: 1 year warranty
Returns: 30-day money-back guarantee
"""

bot = CustomerServiceBot("your-api-key-here", knowledge)
print(bot.chat("What features does your smart watch have?"))
print(bot.chat("What's the price?"))