Eurone Gen AI Bootcamp Q&A

Référence Q&A du Bootcamp Euron - Réponses Instantanées

Objectif

Répondre instantanément à toute question du Bootcamp Euron Gen AI Certification en consultant les extraits de code, configurations ou étapes de dépannage appropriés à partir de cette référence.

Contexte Rapide

• Bootcamp: Euron Gen AI Certification Bootcamp 2.0 (par Sudhanshu sir)
• Portail: https://euron.one/euri
• URL de Base de l'API: https://api.euron.one/api/v1/euri
• Authentification: Authorization: Bearer <EURI_API_KEY>
• Limite quotidienne: 200 000 tokens (entrée + sortie), réinitialisation à minuit UTC
• Principe clé: Euri est compatible OpenAI. Partout où vous utilisez ChatOpenAI(...) ou OpenAI(...), ajoutez simplement base_url pointant vers Euri.

---

QUESTIONS & RÉPONSES COURANTES

Q1 : "Comment utiliser Euri avec LangChain ?"

Réponse (prête à copier-coller) :

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4.1-nano",  # ou gemini-2.5-flash, n'importe quel modèle Euri
    api_key="votre-clé-api-euri",
    base_url="https://api.euron.one/api/v1/euri"
)

response = llm.invoke("Bonjour !")
print(response.content)

Voilà. Partout où Sudhanshu sir utilise ChatOpenAI(...), ajoutez simplement le paramètre base_url pointant vers Euri. Tout le reste (agents, chaînes, outils) reste exactement le même.

---

Q2 : "Comment utiliser Euri avec le SDK OpenAI Python ?"

from openai import OpenAI

client = OpenAI(
    api_key="votre-clé-api-euri",
    base_url="https://api.euron.one/api/v1/euri"
)

response = client.chat.completions.create(
    model="gemini-2.5-flash",
    messages=[{"role": "user", "content": "Bonjour !"}]
)
print(response.choices[0].message.content)

---

Q3 : "Comment utiliser le SDK Euri Python (euriai) ?"

pip install euriai

from euriai import EuriaiClient

client = EuriaiClient(
    api_key="votre-clé-api-euri",
    model="gemini-2.5-flash"
)

response = client.generate_completion(
    prompt="Qu'est-ce que l'IA ?",
    temperature=0.7,
    max_tokens=500
)
print(response["choices"][0]["message"]["content"])

---

Q4 : "Comment utiliser Euri avec l'intégration LangChain d'euriai ?"

pip install euriai[langchain]

from euriai.langchain import EuriaiChatModel

chat = EuriaiChatModel(api_key="votre-clé", model="gemini-2.5-flash")
result = chat.invoke("Expliquez Docker")
print(result.content)

---

Q5 : "Comment utiliser Euri avec HTTP brut / requests ?"

import requests

response = requests.post(
    "https://api.euron.one/api/v1/euri/chat/completions",
    headers={
        "Authorization": "Bearer votre-clé-api-euri",
        "Content-Type": "application/json",
    },
    json={
        "model": "gemini-2.5-flash",
        "messages": [{"role": "user", "content": "Bonjour !"}],
        "temperature": 0.7,
        "max_tokens": 500,
    },
)

data = response.json()
print(data["choices"][0]["message"]["content"])

---

Q6 : "Comment utiliser Euri avec curl ?"

curl -X POST https://api.euron.one/api/v1/euri/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer VOTRE_CLÉ_API" \
  -d '{
    "messages": [{"role": "user", "content": "Bonjour !"}],
    "model": "gemini-2.5-flash"
  }'

---

Q7 : "Comment utiliser Euri avec TypeScript / Node.js ?"

const response = await fetch("https://api.euron.one/api/v1/euri/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.EURI_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "gemini-2.5-flash",
    messages: [{ role: "user", content: "Bonjour !" }],
  }),
});

const data = await response.json();
console.log(data.choices[0].message.content);

---

Q8 : "Comment utiliser Euri dans n8n ?"

Option A — Identifiant OpenAI (le plus simple) :

1. Créez un identifiant "OpenAI" dans n8n
2. Définissez la clé API : votre clé API Euri
3. Définissez l'URL de base : https://api.euron.one/api/v1/euri
4. Utilisez n'importe quel nœud OpenAI — il est routé automatiquement via Euri

Option B — Nœud HTTP Request :

• Méthode : POST
• URL : https://api.euron.one/api/v1/euri/chat/completions
• En-têtes : Authorization: Bearer {{ $env.EURI_API_KEY }}
• Corps JSON :

{
  "model": "gemini-2.5-flash",
  "messages": [
    {"role": "system", "content": "Vous êtes un assistant utile."},
    {"role": "user", "content": "{{ $json.userMessage }}"}
  ],
  "temperature": 0.7,
  "max_tokens": 1000
}

• Extraire la réponse : {{ $json.choices[0].message.content }}

---

Q9 : "Comment générer des embeddings avec Euri ?"

from openai import OpenAI

client = OpenAI(
    api_key="votre-clé-api-euri",
    base_url="https://api.euron.one/api/v1/euri"
)

response = client.embeddings.create(
    model="gemini-embedding-001",  # ou text-embedding-3-small
    input="Votre texte ici"
)
print(response.data[0].embedding[:5])  # 5 premières dimensions

Modèles d'embedding disponibles :

Modèle	ID	Dimensions
Gemini Embedding 001	gemini-embedding-001	1536
Text Embedding 3 Small	text-embedding-3-small	1536
M2 BERT 80M 32K	togethercomputer/m2-bert-80M-32k-retrieval	1536

---

Q10 : "Comment générer des images avec Euri ?"

from openai import OpenAI

client = OpenAI(
    api_key="votre-clé-api-euri",
    base_url="https://api.euron.one/api/v1/euri"
)

response = client.images.generate(
    model="gemini-3-pro-image-preview",
    prompt="Une ville futuriste au coucher du soleil, style cyberpunk",
    n=1
)
print(response.data[0].url)

---

Q11 : "Quel modèle dois-je utiliser ?"

Cas d'utilisation	ID du modèle	Pourquoi
Usage général	gemini-2.5-flash	Meilleur équilibre vitesse + qualité
Raisonnement complexe	gemini-2.5-pro	Contexte 2M, meilleur raisonnement
Rapide et économique	gpt-4.1-nano	Le moins cher, ultra-rapide
Aussi rapide et économique	gpt-5-nano-2025-08-07	Modèle nano plus récent
Génération de code	gpt-4.1-mini ou gemini-2.5-flash	Bon pour le code
Recherche web	groq/compound	Recherche web intégrée
Embeddings (RAG)	gemini-embedding-001	Embeddings de meilleure qualité
Génération d'images	gemini-3-pro-image-preview	Seul modèle d'image sur Euri

Liste complète des modèles (24 modèles) :

Modèles Texte (20) :

• qwen/qwen3-32b (Alibaba, 128K)
• gemini-2.0-flash (Google, 1M)
• gemini-2.5-pro (Google, 2M)
• gemini-2.5-flash (Google, 1M)
• gemini-2.5-pro-preview-06-05 (Google, 2M)
• gemini-2.5-flash-preview-05-20 (Google, 1M)
• gemini-2.5-flash-lite-preview-06-17 (Google, 128K)
• groq/compound (Groq, 131K)
• groq/compound-mini (Groq, 131K)
• llama-4-scout-17b-16e-instruct (Meta, 128K)
• llama-4-maverick-17b-128e-instruct (Meta, 128K)
• llama-3.3-70b-versatile (Meta, 128K)
• llama-3.1-8b-instant (Meta, 128K)
• llama-guard-4-12b (Meta, 128K)
• gpt-5-nano-2025-08-07 (OpenAI, 128K)
• gpt-5-mini-2025-08-07 (OpenAI, 128K)
• gpt-4.1-nano (OpenAI, 128K)
• gpt-4.1-mini (OpenAI, 128K)
• openai/gpt-oss-20b (OpenAI, 128K)
• openai/gpt-oss-120b (OpenAI, 128K)

---

Q12 : "J'obtiens une erreur / L'API ne fonctionne pas"

Correctifs courants :

1. 401 Non autorisé — La clé API est incorrecte ou manquante

   • Obtenez votre clé sur https://euron.one/euri
   • L'en-tête doit être : Authorization: Bearer VOTRE_CLÉ (pas Api-Key ni X-API-Key)

2. Modèle introuvable — Mauvais ID de modèle

   • Utilisez les identifiants exacts de la liste des modèles ci-dessus (sensible à la casse)
   • Erreur courante : gpt-4.1 au lieu de gpt-4.1-nano

3. Limite de débit / 429 — Limite quotidienne de 200K tokens atteinte

   • Attendez la réinitialisation à minuit UTC
   • Utilisez des invites plus courtes et des valeurs max_tokens plus faibles
   • Passez à des modèles moins chers (gpt-4.1-nano)

4. Le contenu de la réponse est un tableau au lieu d'une chaîne

   • Euri renvoie parfois content comme [{type:"text", text:"..."}] au lieu d'une chaîne simple
   • Gérez les deux : content if isinstance(content, str) else content[0]["text"]

5. Problèmes de version LangChain

   • Utilisez langchain_openai (pas langchain.chat_models)
   • pip install langchain-openai (paquet séparé)

6. "Connexion refusée" ou délai d'attente

   • Vérifiez la connexion Internet
   • Vérifiez l'URL de base : https://api.euron.one/api/v1/euri (pas de barre oblique finale)

---

Q13 : "Comment construire des agents/chaînes avec Euri + LangChain ?"

Identique à LangChain normal — utilisez simplement le LLM Euri :

from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import Tool

# LLM alimenté par Euri
llm = ChatOpenAI(
    model="gemini-2.5-flash",
    api_key="votre-clé-api-euri",
    base_url="https://api.euron.one/api/v1/euri"
)

# Utilisez llm dans n'importe quelle chaîne, agent ou outil — fonctionne de manière identique à OpenAI

Point clé : Euri est un remplacement direct. N'importe quel tutoriel LangChain ou code de Sudhanshu sir fonctionne — ajoutez simplement le paramètre base_url.

---

Q14 : "Comment configurer les serveurs MCP du cours ?"

Guide complet : Voir Angelina AI System/Euron/MAIL-MCP-SETUP.md

Modèle de configuration rapide pour tout serveur MCP :

cd "Gen AI 2.O/MCP/<dossier-serveur>"
python3 -m venv venv
source venv/bin/activate       # macOS/Linux
# venv\Scripts\activate        # Windows
pip install -r requirements.txt
python authenticate.py          # Uniquement pour les services Google

8 serveurs MCP disponibles :

1. Gmail (4 outils) — envoyer, lire, rechercher, marquer comme lu
2. Google Calendar (5 outils) — lister, créer, rechercher, supprimer des événements
3. Google Sheets (5 outils) — lire, écrire, ajouter, créer, lister
4. Supabase (6 outils) — interroger, insérer, mettre à jour, supprimer, SQL
5. MongoDB (7 outils) — interroger, insérer, mettre à jour, supprimer, agréger
6. AWS S3 (6 outils) — lister, télécharger, uploader, supprimer, URL présignées
7. Azure Blob (7 outils) — lister, télécharger, uploader, supprimer, URL SAS
8. Réseaux Sociaux (10 outils) — YouTube + Instagram + Facebook

Emplacement de la configuration Claude Desktop :

• macOS : ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows : %APPDATA%\Claude\claude_desktop_config.json

Emplacement de la configuration Cursor :

• ~/.cursor/mcp.json (macOS/Linux)
• %USERPROFILE%\.cursor\mcp.json (Windows)

Erreurs MCP courantes :

• "MCP Server déconnecté" → Assurez-vous que le script contient mcp.run(transport="stdio"), n'utilisez pas -m mcp run
• "Jeton d'authentification manquant" → Exécutez à nouveau python authenticate.py
• "Échec du renouvellement du jeton" → Supprimez token.json, ré-authentifiez
• "Google n'a pas vérifié cette application" → Cliquez sur Avancé → Accéder à l'application (sûr, c'est votre propre application)

---

Q15 : "Comment utiliser Euri avec CrewAI / AutoGen / autres frameworks ?"

Même modèle — Euri est compatible OpenAI :

CrewAI :

from crewai import LLM

llm = LLM(
    model="openai/gemini-2.5-flash",
    api_key="votre-clé-euri",
    base_url="https://api.euron.one/api/v1/euri"
)

AutoGen :

config_list = [{
    "model": "gemini-2.5-flash",
    "api_key": "votre-clé-euri",
    "base_url": "https://api.euron.one/api/v1/euri"
}]

LiteLLM :

import litellm
response = litellm.completion(
    model="openai/gemini-2.5-flash",
    api_key="votre-clé-euri",
    api_base="https://api.euron.one/api/v1/euri",
    messages=[{"role": "user", "content": "Bonjour !"}]
)

Règle générale : Tout framework qui prend en charge une base_url personnalisée ou des points de terminaison compatibles OpenAI fonctionne avec Euri. Remplacez simplement l'URL de base.

---

Q16 : "Combien de tokens ai-je ? Quelle est la limite ?"

• 200 000 tokens par jour (entrée + sortie combinées)
• Réinitialisation à minuit UTC
• Cela correspond à environ 150 000 mots ou 300+ pages de texte par jour
• Pour les travaux pratiques, c'est largement suffisant — vous n'atteindrez pas les limites pendant le cours
• Astuce : Utilisez gpt-4.1-nano ou gemini-2.5-flash-lite pour les tests afin d'économiser des tokens

---

Q17 : "Où puis-je obtenir ma clé API ?"

1. Allez sur https://euron.one/euri
2. Connectez-vous avec votre compte Euron
3. Copiez votre clé API depuis le tableau de bord
4. Utilisez-la comme api_key dans le code ou Authorization: Bearer <clé> dans les en-têtes HTTP

---

Q18 : "Puis-je utiliser Euri gratuitement ?"

Oui ! Euri vous donne 200 000 tokens gratuits par jour. Aucune carte de crédit nécessaire. Accès à tous les 24 modèles, y compris GPT-4.1, Gemini 2.5, Llama 4, et plus.

---

MODÈLE DE RÉPONSE

Lorsque vous répondez aux doutes du bootcamp, utilisez ce format :

Salut [Nom] ! [Brève explication du correctif]

[Extrait de code — prêt à copier-coller]

[Explication en une ligne de ce qui a changé]

Bons modèles gratuits à utiliser :
- gpt-4.1-nano — rapide et économique
- gemini-2.5-flash — meilleur usage général
- gemini-2.5-pro — le plus intelligent

Vous avez 200 000 tokens gratuits par jour, vous n'atteindrez donc pas les limites pendant les travaux pratiques.

---

RÉFÉRENCE DES FICHIERS

Pour des réponses plus approfondies, consultez ces fichiers :

• Documentation complète de l'API : Angelina AI System/Euron/README.md
• Client TypeScript : Angelina AI System/Euron/euri-client.ts
• Définitions des modèles : Angelina AI System/Euron/euri-models.ts
• Exemples Python : Angelina AI System/Euron/examples/python-sdk.py
• Exemples TypeScript : Angelina AI System/Euron/examples/basic-chat.ts
• Intégration n8n : Angelina AI System/Euron/examples/n8n-http-request.md
• Guide de configuration MCP : Angelina AI System/Euron/MAIL-MCP-SETUP.md
• Arène de modèles : Angelina AI System/Euron/model-arena/arena.html
• Testeur d'API : Angelina AI System/Euron/euri-tester/index.html

---

Schéma

Entrées

Nom	Type	Requis	Description
question	string	Oui	Question d'un étudiant du bootcamp sur l'API Euri, MCP, les modèles ou les erreurs

Sorties

Nom	Type	Description
answer	string	Réponse prête à copier-coller avec des extraits de code

Coût

Gratuit (recherche dans la référence uniquement)