Guide Hackathon Claude : Démarrer Rapidement avec l'API et Claude Code

Phase 1 : Setup (5 minutes)

Étape 1 : Obtenir la Clé API

1. →Allez sur console.anthropic.com
2. →Créez un compte (email + vérification)
3. →Ajoutez $5-10 de crédits (Settings > Billing)
4. →Créez une clé API (Settings > API Keys)
5. →Copiez la clé : sk-ant-api03-...

Étape 2 : Installer le SDK

# Python
pip install anthropic

# TypeScript/Node.js
npm install @anthropic-ai/sdk

Étape 3 : Premier Appel (en 60 secondes)

import anthropic

client = anthropic.Anthropic(api_key="sk-ant-api03-VOTRE-CLE")

msg = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello Claude ! Confirme que l'API fonctionne."}]
)
print(msg.content[0].text)

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

const client = new Anthropic({ apiKey: "sk-ant-api03-VOTRE-CLE" });

const msg = await client.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "Hello Claude ! Confirme que l'API fonctionne." },
  ],
});
console.log(msg.content[0].text);

Si ça fonctionne → passez à la Phase 2. Si ça ne fonctionne pas :

Phase 2 : Patterns Utiles (Copier-Coller Ready)

Pattern 1 : Chatbot avec Mémoire

import anthropic

client = anthropic.Anthropic()
conversation = []

def chat(message):
    conversation.append({"role": "user", "content": message})
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        system="Tu es l'assistant de [VOTRE APP]. Tu aides les utilisateurs à [OBJECTIF].",
        messages=conversation
    )
    
    reply = response.content[0].text
    conversation.append({"role": "assistant", "content": reply})
    return reply

# Test
print(chat("Bonjour, que fais-tu ?"))
print(chat("Donne-moi un exemple."))

Pattern 2 : Streaming (UI en temps réel)

import anthropic

client = anthropic.Anthropic()

def stream_response(prompt):
    with client.messages.stream(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{"role": "user", "content": prompt}]
    ) as stream:
        full_response = ""
        for text in stream.text_stream:
            print(text, end="", flush=True)
            full_response += text
    return full_response

Pattern 3 : Extraction JSON Structurée

import anthropic
import json

client = anthropic.Anthropic()

def extract_json(text, schema_description):
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": f"""Extrais les informations suivantes du texte et retourne UNIQUEMENT un JSON valide.

Schéma attendu : {schema_description}

Texte : {text}"""
        }]
    )
    return json.loads(response.content[0].text)

# Utilisation
result = extract_json(
    "Marie, 28 ans, dev Python chez TechCorp à Lyon, marie@tech.com",
    '{"name": str, "age": int, "role": str, "company": str, "city": str, "email": str}'
)
print(result)
# {"name": "Marie", "age": 28, "role": "dev Python", ...}

Pattern 4 : Analyse d'Image

import anthropic
import base64

client = anthropic.Anthropic()

def analyze_image(image_path, question):
    with open(image_path, "rb") as f:
        image_data = base64.standard_b64encode(f.read()).decode("utf-8")
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": [
                {"type": "image", "source": {
                    "type": "base64",
                    "media_type": "image/png",
                    "data": image_data
                }},
                {"type": "text", "text": question}
            ]
        }]
    )
    return response.content[0].text

# Utilisation
print(analyze_image("screenshot.png", "Décris ce que tu vois et identifie les problèmes UX."))

Pattern 5 : Tool Use (Agent)

import anthropic
import json

client = anthropic.Anthropic()

tools = [{
    "name": "search_database",
    "description": "Cherche un produit par nom ou catégorie dans la base de données.",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {"type": "string", "description": "Terme de recherche"},
            "category": {"type": "string", "enum": ["tech", "food", "clothing"]}
        },
        "required": ["query"]
    }
}]

def handle_tool_call(name, input_data):
    if name == "search_database":
        # Simulez votre vraie base de données ici
        return [{"name": "MacBook Pro", "price": 2499}, {"name": "iPad Air", "price": 799}]
    return {"error": "Tool not found"}

def agent_chat(message):
    messages = [{"role": "user", "content": message}]
    
    while True:
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=2048,
            tools=tools,
            messages=messages
        )
        
        if response.stop_reason == "end_turn":
            return response.content[0].text
        
        messages.append({"role": "assistant", "content": response.content})
        
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = handle_tool_call(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": json.dumps(result)
                })
        
        messages.append({"role": "user", "content": tool_results})

Phase 3 : Claude Code pour le Prototypage

Claude Code accélère massivement le développement pendant un hackathon.

Commandes Clés

Workflow Hackathon avec Claude Code

# 1. Initialiser le projet
mkdir mon-hackathon && cd mon-hackathon
claude "Crée un projet Python avec FastAPI, un endpoint /chat qui utilise l'API Claude, 
et un frontend HTML simple. Inclus un Dockerfile et un README."

# 2. Itérer rapidement
claude "Ajoute le streaming SSE pour les réponses Claude"
claude "Ajoute un historique de conversation en mémoire"
claude "Ajoute le support des images uploadées"

# 3. Corriger les problèmes
claude "Le streaming ne fonctionne pas sur le frontend, corrige le code JavaScript"

# 4. Préparer le déploiement
claude "Configure le Dockerfile pour Railway/Render"

Phase 4 : Déploiement Rapide

Option 1 : Vercel (Frontend + API Routes)

# Next.js avec API Routes
npx create-next-app@latest my-app
cd my-app
npm install @anthropic-ai/sdk
# Ajoutez votre code dans app/api/chat/route.ts
vercel deploy

Option 2 : Railway (Backend Python)

# Créez un Procfile
echo "web: uvicorn app:app --host 0.0.0.0 --port $PORT" > Procfile

# Déployez
railway login
railway init
railway up
# Ajoutez ANTHROPIC_API_KEY dans les variables d'environnement

Option 3 : Render

# render.yaml
# services:
#   - type: web
#     name: claude-hackathon
#     runtime: python
#     buildCommand: pip install -r requirements.txt
#     startCommand: uvicorn app:app --host 0.0.0.0 --port $PORT

# Push sur GitHub → connectez à Render → déploiement auto

Comparaison Plateformes de Déploiement

Budget API : Combien Prévoir ?

Astuces pour réduire les coûts :

1. →Utilisez Haiku pour les tâches simples (classification, extraction)
2. →Activez le prompt caching pour les system prompts répétitifs
3. →Limitez max_tokens — ne demandez pas 4096 si 512 suffit
4. →Mettez un rate limit côté application

Les 10 Erreurs de Hackathon à Éviter

Checklist Hackathon

Avant le hackathon (J-1)

• → Compte Anthropic créé et crédits ajoutés
• → Clé API générée et testée
• → SDK installé dans votre environnement de développement
• → Premier appel API réussi
• → Claude Code installé

Pendant le hackathon

• → Idée validée et scope réduit au minimum viable
• → Premier prototype fonctionnel (1ère heure)
• → Feature principale complète (mi-hackathon)
• → Déploiement réussi (2h avant la fin)
• → Démo préparée et testée (1h avant la fin)

Ressources Essentielles