import anthropic

client = anthropic.Anthropic()

# Utiliser Opus pour du raisonnement complexe
response_opus = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Analyse cette architecture..."}]
)

# Utiliser Sonnet pour du coding standard
response_sonnet = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=2048,
    messages=[{"role": "user", "content": "Ecris une fonction Python..."}]
)

# Utiliser Haiku pour de la classification rapide
response_haiku = client.messages.create(
    model="claude-haiku-4-5-20251001",
    max_tokens=100,
    messages=[{"role": "user", "content": "Classifie: positif/negatif/neutre"}]
)

# Calculateur de couts Claude
def calculate_cost(model, input_tokens, output_tokens, cached_input=0):
    pricing = {
        "opus":   {"input": 5.00,  "output": 25.00, "cache": 0.50},
        "sonnet": {"input": 3.00,  "output": 15.00, "cache": 0.30},
        "haiku":  {"input": 1.00,  "output": 5.00,  "cache": 0.10},
    }
    p = pricing[model]
    fresh_input = input_tokens - cached_input
    cost = (fresh_input / 1_000_000 * p["input"] +
            cached_input / 1_000_000 * p["cache"] +
            output_tokens / 1_000_000 * p["output"])
    return round(cost, 6)

# Exemple : chatbot Sonnet, 1000 tokens in, 500 out
print(calculate_cost("sonnet", 1000, 500))  # $0.0105

# Avec caching (800 tokens caches sur 1000)
print(calculate_cost("sonnet", 1000, 500, cached_input=800))  # $0.00084

# Python SDK
pip install anthropic

# TypeScript SDK
npm install @anthropic-ai/sdk

# Configurer la cle API (variable d'environnement)
export ANTHROPIC_API_KEY="sk-ant-api03-votre-cle-ici"

import anthropic

# Le SDK lit automatiquement ANTHROPIC_API_KEY
client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Bonjour Claude ! Explique-moi ce qu'est une API en 3 phrases."}
    ]
)

# Acceder au texte de la reponse
print(message.content[0].text)

# Voir l'usage des tokens
print(f"Input: {message.usage.input_tokens} tokens")
print(f"Output: {message.usage.output_tokens} tokens")

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

const client = new Anthropic();

const message = await client.messages.create({
  model: "claude-sonnet-4-5-20250929",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "Bonjour Claude !" }
  ]
});

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

{
  "id": "msg_01XFDUDYJgAACzvnptvVoYEL",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Une API (Application Programming Interface) est..."
    }
  ],
  "model": "claude-sonnet-4-5-20250929",
  "stop_reason": "end_turn",
  "usage": {
    "input_tokens": 25,
    "output_tokens": 150
  }
}

message = client.messages.create(
    model="claude-sonnet-4-5-20250929",   # Modele a utiliser
    max_tokens=2048,                       # Max tokens en sortie
    temperature=0.7,                       # Creativite (0=deterministe, 1=creatif)
    system="Tu es un architecte logiciel senior avec 20 ans d'experience. "
           "Tu reponds de maniere structuree avec des exemples concrets. "
           "Tu utilises des diagrammes ASCII quand c'est utile.",
    stop_sequences=["---END---"],          # Arret sur cette sequence
    messages=[
        {"role": "user", "content": "Compare monolithe vs microservices"}
    ]
)

import anthropic

client = anthropic.Anthropic()

# Methode 1 : Context manager (recommande)
with client.messages.stream(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Ecris un guide d'architecture"}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

# Acces au message final
final = stream.get_final_message()
print(f"\nTokens: {final.usage.input_tokens} in, {final.usage.output_tokens} out")

import anthropic
import time
import random

def call_claude(messages, model="claude-sonnet-4-5-20250929", max_retries=5):
    client = anthropic.Anthropic()

    for attempt in range(max_retries):
        try:
            return client.messages.create(
                model=model,
                max_tokens=1024,
                messages=messages
            )
        except anthropic.RateLimitError as e:
            # Backoff exponentiel + jitter
            wait = (2 ** attempt) + random.uniform(0, 1)
            print(f"Rate limited. Retry dans {wait:.1f}s...")
            time.sleep(wait)
        except anthropic.APIStatusError as e:
            if e.status_code >= 500:  # Erreur serveur
                wait = 2 ** attempt
                print(f"Erreur serveur {e.status_code}. Retry dans {wait}s...")
                time.sleep(wait)
            else:
                raise  # Erreur client (400, 401, 403) = pas de retry

    raise Exception(f"Echec apres {max_retries} tentatives")

import anthropic
import base64

client = anthropic.Anthropic()

# Lire et encoder l'image
with open("architecture-diagram.png", "rb") as f:
    image_data = base64.standard_b64encode(f.read()).decode("utf-8")

message = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=2048,
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "image",
                "source": {
                    "type": "base64",
                    "media_type": "image/png",
                    "data": image_data
                }
            },
            {
                "type": "text",
                "text": "Analyse ce diagramme d'architecture. Identifie les composants, les flux de donnees, et les points faibles potentiels."
            }
        ]
    }]
)
print(message.content[0].text)

message = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "image",
                "source": {
                    "type": "url",
                    "url": "https://example.com/diagram.png"
                }
            },
            {"type": "text", "text": "Que montre cette image ?"}
        ]
    }]
)

# L'historique est gere manuellement via le tableau messages
conversation = []

def chat(user_message):
    conversation.append({"role": "user", "content": user_message})

    response = client.messages.create(
        model="claude-sonnet-4-5-20250929",
        max_tokens=1024,
        system="Tu es un architecte cloud expert.",
        messages=conversation
    )

    assistant_msg = response.content[0].text
    conversation.append({"role": "assistant", "content": assistant_msg})
    return assistant_msg

# Utilisation
print(chat("Qu'est-ce que Kubernetes ?"))
print(chat("Comment le deployer sur AWS ?"))  # Claude a le contexte precedent
print(chat("Et les couts ?"))  # Claude a tout le contexte

# Creer un batch de requetes (traitement asynchrone, 50% moins cher)
batch = client.messages.batches.create(
    requests=[
        {
            "custom_id": "analysis-doc-1",
            "params": {
                "model": "claude-sonnet-4-5-20250929",
                "max_tokens": 2048,
                "messages": [{"role": "user", "content": "Analyse ce document: ..."}]
            }
        },
        {
            "custom_id": "analysis-doc-2",
            "params": {
                "model": "claude-sonnet-4-5-20250929",
                "max_tokens": 2048,
                "messages": [{"role": "user", "content": "Analyse ce document: ..."}]
            }
        }
    ]
)

# Verifier le statut
status = client.messages.batches.retrieve(batch.id)
print(f"Statut: {status.processing_status}")  # in_progress, ended

# Recuperer les resultats quand termine
if status.processing_status == "ended":
    for result in client.messages.batches.results(batch.id):
        print(f"{result.custom_id}: {result.result.message.content[0].text[:100]}")

"Classifie le sentiment de ce texte : 'Super produit, je recommande !'"

"Classifie le sentiment :

Texte: 'Excellent service !' → Positif
Texte: 'Tres decevant' → Negatif
Texte: 'Correct, sans plus' → Neutre

Texte: 'Super produit, je recommande !' →"

"Analyse cette architecture et identifie les problemes.
Reflechis etape par etape :

1. Identifie chaque composant
2. Trace les flux de donnees
3. Verifie la scalabilite de chaque composant
4. Identifie les single points of failure
5. Evalue la resilience
6. Formule tes recommandations

Architecture : [description]"

<context>
Vous analysez un systeme e-commerce avec 1M utilisateurs.
Le systeme actuel est un monolithe Java deploye sur un seul serveur.
</context>

<task>
Identifiez les 3 principaux risques architecturaux et proposez des solutions.
</task>

<format>
Repondez en JSON strict avec cette structure :
[
  {
    "risk_name": "string",
    "severity": 1-5,
    "description": "string (max 50 mots)",
    "mitigation": "string (max 50 mots)"
  }
]
</format>

<constraints>
- Maximum 3 risques
- Severity 5 = critique, 1 = mineur
- JSON valide uniquement, pas de texte autour
</constraints>

import json

message = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    system="Tu es un assistant qui repond UNIQUEMENT en JSON valide. Pas de texte, pas de markdown, juste du JSON.",
    messages=[{"role": "user", "content": prompt_xml}]
)

# Parser la reponse JSON
data = json.loads(message.content[0].text)
for risk in data:
    print(f"[{risk['severity']}/5] {risk['risk_name']}: {risk['mitigation']}")

Tu es ArchBot, un assistant architecte logiciel senior avec 25 ans d'experience.

ROLE:
- Tu analyses les architectures systeme
- Tu identifies les risques et proposes des ameliorations
- Tu connais les patterns: microservices, event-driven, CQRS, saga

REGLES:
1. Toujours structurer ta reponse avec des sections claires
2. Utiliser des diagrammes ASCII quand pertinent
3. Quantifier quand possible (latence, throughput, cout)
4. Citer les trade-offs de chaque recommandation
5. Ne pas inventer de chiffres - dire "a estimer" si incertain

FORMAT DE SORTIE:
## Analyse
[Description du probleme]

## Architecture Proposee
[Diagramme + description]

## Trade-offs
| Option | Avantages | Inconvenients |

## Recommandation
[Recommandation finale justifiee]

GUARDRAILS:
- Ne pas recommander de technologies sans justification
- Toujours considerer la scalabilite et le cout
- Signaler les single points of failure
- Ne jamais conseiller de stocker des secrets en clair

import anthropic

client = anthropic.Anthropic()

# System prompt avec cache_control
message = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": """Tu es un architecte expert. Voici la documentation complete
du systeme (5000 mots)... [LONG CONTEXTE ICI]...""",
            "cache_control": {"type": "ephemeral"}  # Active le cache
        }
    ],
    messages=[{"role": "user", "content": "Quelle est l'architecture actuelle ?"}]
)

# Verifier l'utilisation du cache
print(f"Cache creation: {message.usage.cache_creation_input_tokens}")
print(f"Cache read: {message.usage.cache_read_input_tokens}")
print(f"Non-cached input: {message.usage.input_tokens}")