Eurón Bootcamp Q&A - Respuesta Instantánea

Eurón Bootcamp Q&A - Referencia de Respuesta Instantánea

Objetivo

Resuelve al instante cualquier duda del Bootcamp de Certificación en IA Generativa de Eurón consultando el fragmento de código, la configuración o el paso de solución de problemas correcto de esta referencia.

Contexto Rápido

• Bootcamp: Eurón Gen AI Certification Bootcamp 2.0 (por Sudhanshu sir)
• Portal: https://euron.one/euri
• URL Base de la API: https://api.euron.one/api/v1/euri
• Autenticación: Authorization: Bearer <EURI_API_KEY>
• Límite diario: 200,000 tokens (entrada + salida), se restablece a medianoche UTC
• Principio clave: Euri es compatible con OpenAI. En cualquier lugar donde uses ChatOpenAI(...) o OpenAI(...), solo agrega base_url apuntando a Euri.

---

PREGUNTAS Y RESPUESTAS COMUNES

P1: "¿Cómo uso Euri con LangChain?"

Respuesta (lista para copiar y pegar):

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4.1-nano",  # o gemini-2.5-flash, cualquier modelo de Euri
    api_key="tu-api-key-de-euri",
    base_url="https://api.euron.one/api/v1/euri"
)

response = llm.invoke("¡Hola!")
print(response.content)

Eso es todo. En todos los lugares donde Sudhanshu sir usa ChatOpenAI(...), solo agrega el parámetro base_url apuntando a Euri. Todo lo demás (agentes, cadenas, herramientas) permanece exactamente igual.

---

P2: "¿Cómo uso Euri con el SDK de OpenAI para Python?"

from openai import OpenAI

client = OpenAI(
    api_key="tu-api-key-de-euri",
    base_url="https://api.euron.one/api/v1/euri"
)

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

---

P3: "¿Cómo uso el SDK de Euri para Python (euriai)?"

pip install euriai

from euriai import EuriaiClient

client = EuriaiClient(
    api_key="tu-api-key-de-euri",
    model="gemini-2.5-flash"
)

response = client.generate_completion(
    prompt="¿Qué es la IA?",
    temperature=0.7,
    max_tokens=500
)
print(response["choices"][0]["message"]["content"])

---

P4: "¿Cómo uso Euri con la integración euriai de LangChain?"

pip install euriai[langchain]

from euriai.langchain import EuriaiChatModel

chat = EuriaiChatModel(api_key="tu-clave", model="gemini-2.5-flash")
result = chat.invoke("Explica Docker")
print(result.content)

---

P5: "¿Cómo uso Euri con HTTP sin procesar / requests?"

import requests

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

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

---

P6: "¿Cómo uso Euri con curl?"

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

---

P7: "¿Cómo uso Euri con 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: "¡Hola!" }],
  }),
});

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

---

P8: "¿Cómo uso Euri en n8n?"

Opción A — Credencial de OpenAI (la más fácil):

1. Crea una credencial "OpenAI" en n8n
2. Establece la clave de API: tu clave de API de Euri
3. Establece la URL base: https://api.euron.one/api/v1/euri
4. Usa cualquier nodo de OpenAI: se enrutará a través de Euri automáticamente

Opción B — Nodo de Solicitud HTTP:

• Método: POST
• URL: https://api.euron.one/api/v1/euri/chat/completions
• Encabezados: Authorization: Bearer {{ $env.EURI_API_KEY }}
• Cuerpo JSON:

{
  "model": "gemini-2.5-flash",
  "messages": [
    {"role": "system", "content": "Eres un asistente útil."},
    {"role": "user", "content": "{{ $json.userMessage }}"}
  ],
  "temperature": 0.7,
  "max_tokens": 1000
}

• Extraer respuesta: {{ $json.choices[0].message.content }}

---

P9: "¿Cómo genero embeddings con Euri?"

from openai import OpenAI

client = OpenAI(
    api_key="tu-api-key-de-euri",
    base_url="https://api.euron.one/api/v1/euri"
)

response = client.embeddings.create(
    model="gemini-embedding-001",  # o text-embedding-3-small
    input="Tu texto aquí"
)
print(response.data[0].embedding[:5])  # Primeras 5 dimensiones

Modelos de embedding disponibles:

Modelo	ID	Dimensiones
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

---

P10: "¿Cómo genero imágenes con Euri?"

from openai import OpenAI

client = OpenAI(
    api_key="tu-api-key-de-euri",
    base_url="https://api.euron.one/api/v1/euri"
)

response = client.images.generate(
    model="gemini-3-pro-image-preview",
    prompt="Una ciudad futurista al atardecer, estilo cyberpunk",
    n=1
)
print(response.data[0].url)

---

P11: "¿Qué modelo debería usar?"

Caso de uso	ID del Modelo	Por qué
Propósito general	gemini-2.5-flash	Mejor equilibrio entre velocidad y calidad
Razonamiento complejo	gemini-2.5-pro	Contexto de 2M, mejor razonamiento
Rápido y barato	gpt-4.1-nano	El más barato, ultrarrápido
También rápido y barato	gpt-5-nano-2025-08-07	Modelo nano más nuevo
Generación de código	gpt-4.1-mini o gemini-2.5-flash	Bueno para código
Búsqueda web	groq/compound	Búsqueda web integrada
Embeddings (RAG)	gemini-embedding-001	Embeddings de mejor calidad
Generación de imágenes	gemini-3-pro-image-preview	Único modelo de imágenes en Euri

Lista completa de modelos (24 modelos):

Modelos de texto (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)

---

P12: "Estoy recibiendo un error / la API no funciona"

Soluciones comunes:

1. 401 No autorizado — La clave de API es incorrecta o falta

   • Obtén tu clave de https://euron.one/euri
   • El encabezado debe ser: Authorization: Bearer TU_CLAVE (no Api-Key ni X-API-Key)

2. Modelo no encontrado — ID de modelo incorrecto

   • Usa los IDs exactos de la lista de modelos anterior (distingue entre mayúsculas y minúsculas)
   • Error común: gpt-4.1 en lugar de gpt-4.1-nano

3. Límite de velocidad / 429 — Alcanzaste el límite diario de 200K tokens

   • Espera hasta la medianoche UTC para que se restablezca
   • Usa indicaciones más cortas y un max_tokens más bajo
   • Cambia a modelos más baratos (gpt-4.1-nano)

4. El contenido de la respuesta es un array en lugar de una cadena

   • Euri a veces devuelve content como [{type:"text", text:"..."}] en lugar de una cadena simple
   • Maneja ambos casos: content if isinstance(content, str) else content[0]["text"]

5. Problemas de versión de LangChain

   • Usa langchain_openai (no langchain.chat_models)
   • pip install langchain-openai (paquete separado)

6. "Conexión rechazada" o tiempo de espera

   • Verifica la conexión a internet
   • Verifica la URL base: https://api.euron.one/api/v1/euri (sin barra al final)

---

P13: "¿Cómo construyo agentes/cadenas con Euri + LangChain?"

Igual que con LangChain normal — solo usa el LLM de Euri:

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

# LLM potenciado por Euri
llm = ChatOpenAI(
    model="gemini-2.5-flash",
    api_key="tu-api-key-de-euri",
    base_url="https://api.euron.one/api/v1/euri"
)

# Usa llm en cualquier cadena, agente o herramienta: funciona de manera idéntica a OpenAI

Conclusión clave: Euri es un reemplazo directo. CUALQUIER tutorial de LangChain o código de Sudhanshu sir funciona — solo agrega el parámetro base_url.

---

P14: "¿Cómo configuro los servidores MCP de la clase?"

Guía completa: Consulta Angelina AI System/Euron/MAIL-MCP-SETUP.md

Patrón de configuración rápida para cualquier servidor MCP:

cd "Gen AI 2.O/MCP/<carpeta-del-servidor>"
python3 -m venv venv
source venv/bin/activate       # macOS/Linux
# venv\Scripts\activate        # Windows
pip install -r requirements.txt
python authenticate.py          # Solo para servicios de Google

8 servidores MCP disponibles:

1. Gmail (4 herramientas) — enviar, leer, buscar, marcar como visto
2. Google Calendar (5 herramientas) — listar, crear, buscar, eliminar eventos
3. Google Sheets (5 herramientas) — leer, escribir, añadir, crear, listar
4. Supabase (6 herramientas) — consultar, insertar, actualizar, eliminar, SQL
5. MongoDB (7 herramientas) — consultar, insertar, actualizar, eliminar, agregar
6. AWS S3 (6 herramientas) — listar, subir, descargar, eliminar, URLs prefirmadas
7. Azure Blob (7 herramientas) — listar, subir, descargar, eliminar, URLs SAS
8. Redes Sociales (10 herramientas) — YouTube + Instagram + Facebook

Ubicación del archivo de configuración de Claude Desktop:

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

Ubicación del archivo de configuración de Cursor:

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

Errores comunes de MCP:

• "Servidor MCP desconectado" → Asegúrate de que el script tenga mcp.run(transport="stdio"), no uses -m mcp run
• "Falta el token de autenticación" → Ejecuta python authenticate.py de nuevo
• "Error al actualizar el token" → Elimina token.json, vuelve a autenticarte
• "Google no ha verificado esta aplicación" → Haz clic en Avanzado → Ir a la Aplicación (es seguro, es tu propia aplicación)

---

P15: "¿Cómo uso Euri con CrewAI / AutoGen / otros frameworks?"

El mismo patrón: Euri es compatible con OpenAI:

CrewAI:

from crewai import LLM

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

AutoGen:

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

LiteLLM:

import litellm
response = litellm.completion(
    model="openai/gemini-2.5-flash",
    api_key="tu-clave-de-euri",
    api_base="https://api.euron.one/api/v1/euri",
    messages=[{"role": "user", "content": "¡Hola!"}]
)

Regla general: Cualquier framework que admita base_url personalizada o endpoints compatibles con OpenAI funciona con Euri. Solo cambia la URL base.

---

P16: "¿Cuántos tokens obtengo? ¿Cuál es el límite?"

• 200,000 tokens por día (entrada + salida combinados)
• Se restablece a la medianoche UTC
• Eso es aproximadamente 150,000 palabras o más de 300 páginas de texto por día
• Para las prácticas, esto es más que suficiente — no alcanzarás los límites durante la clase
• Consejo: Usa gpt-4.1-nano o gemini-2.5-flash-lite para hacer pruebas y conservar tokens

---

P17: "¿Dónde obtengo mi clave de API?"

1. Ve a https://euron.one/euri
2. Inicia sesión con tu cuenta de Euron
3. Copia tu clave de API desde el panel
4. Úsala como api_key en el código o Authorization: Bearer <clave> en los encabezados HTTP

---

P18: "¿Puedo usar Euri gratis?"

¡Sí! Euri te da 200,000 tokens gratis por día. No necesitas tarjeta de crédito. Acceso a los 24 modelos, incluyendo GPT-4.1, Gemini 2.5, Llama 4 y más.

---

PLANTILLA DE RESPUESTA

Al responder dudas del bootcamp, usa este formato:

¡Hola [Nombre]! [Breve explicación de la solución]

[Fragmento de código — listo para copiar y pegar]

[Explicación de una línea sobre lo que cambió]

Buenos modelos gratuitos para usar:
- gpt-4.1-nano — rápido y barato
- gemini-2.5-flash — mejor propósito general
- gemini-2.5-pro — el más inteligente

Tienes 200K tokens gratis/día, por lo que no alcanzarás los límites durante las prácticas.

---

REFERENCIA DE ARCHIVOS

Para respuestas más detalladas, consulta estos archivos:

• Documentación completa de la API: Angelina AI System/Euron/README.md
• Cliente TypeScript: Angelina AI System/Euron/euri-client.ts
• Definiciones de modelos: Angelina AI System/Euron/euri-models.ts
• Ejemplos en Python: Angelina AI System/Euron/examples/python-sdk.py
• Ejemplos en TypeScript: Angelina AI System/Euron/examples/basic-chat.ts
• Integración con n8n: Angelina AI System/Euron/examples/n8n-http-request.md
• Guía de configuración de MCP: Angelina AI System/Euron/MAIL-MCP-SETUP.md
• Model Arena: Angelina AI System/Euron/model-arena/arena.html
• Probador de API: Angelina AI System/Euron/euri-tester/index.html

---

Esquema

Entradas

Nombre	Tipo	Obligatorio	Descripción
question	string	Sí	Pregunta del estudiante del bootcamp sobre la API de Euri, MCP, modelos o errores

Salidas

Nombre	Tipo	Descripción
answer	string	Respuesta lista para copiar y pegar con fragmentos de código

Costo

Gratuito (solo consulta de referencia)