Integración de GPT/Claude APIs en backend Node.js/Python

Concepto clave

La integración de APIs de GPT y Claude en backend es como construir un puente entre tu aplicación y un cerebro artificial. No se trata solo de enviar prompts, sino de crear un sistema de comunicación robusto que maneje errores, optimice costos y mantenga consistencia en las respuestas. Imagina que eres un director de orquesta: tu backend es la partitura, y las APIs son los músicos que necesitan instrucciones precisas para tocar en armonía.

En producción, el prompt engineering sistemático significa diseñar plantillas reutilizables, gestionar contextos largos y asegurar que cada llamada a la API aporte valor medible. Es similar a cómo un chef profesional organiza su cocina: ingredientes preparados (prompts base), recetas probadas (flujos de trabajo) y control de calidad (validación de respuestas). La clave está en tratar los prompts como código: versionados, testeados y documentados.

Cómo funciona en la práctica

Veamos un ejemplo real: integrar Claude API en un backend Node.js para generar resúmenes automáticos de artículos. Primero, configuras la autenticación con variables de entorno. Luego, diseñas un prompt template que incluya el artículo como contexto y especifique el formato de salida. Finalmente, implementas manejo de errores para casos como límites de tokens o tiempo de espera agotado.

Paso a paso:

1. Configurar cliente API con clave secreta desde variables de entorno
2. Crear función asíncrona que reciba el texto del artículo
3. Construir prompt estructurado con instrucciones claras
4. Enviar solicitud con parámetros optimizados (temperature, max_tokens)
5. Procesar respuesta y extraer el resumen
6. Implementar reintentos para errores temporales
7. Registrar métricas para monitoreo

Codigo en accion

Ejemplo Node.js con Claude API:

// Configuración inicial - ANTES (enfoque básico)
const { Anthropic } = require('@anthropic-ai/sdk');
const anthropic = new Anthropic({
  apiKey: process.env.CLAUDE_API_KEY,
});

async function generateSummaryBasic(text) {
  const prompt = `Resume este artículo: ${text}`;
  
  try {
    const response = await anthropic.messages.create({
      model: "claude-3-opus-20240229",
      max_tokens: 500,
      messages: [{ role: "user", content: prompt }]
    });
    
    return response.content[0].text;
  } catch (error) {
    console.error("Error:", error);
    return null;
  }
}

Versión mejorada - DESPUES (sistemática):

// Sistema de prompting estructurado
class ArticleSummarizer {
  constructor(apiClient) {
    this.client = apiClient;
    this.promptTemplate = `
Eres un asistente especializado en resumir artículos técnicos.

ARTÍCULO:
{article}

INSTRUCCIONES:
1. Extrae los 3 puntos principales
2. Identifica el público objetivo
3. Resume en máximo 200 palabras
4. Formato: Markdown con viñetas

RESUMEN:`;
  }

  async generateSummary(articleText, options = {}) {
    const maxRetries = options.maxRetries || 3;
    const timeoutMs = options.timeoutMs || 30000;
    
    const prompt = this.promptTemplate.replace('{article}', articleText);
    
    for (let attempt = 1; attempt <= maxRetries; attempt++) {
      try {
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
        
        const response = await this.client.messages.create({
          model: options.model || "claude-3-sonnet-20240229",
          max_tokens: options.maxTokens || 300,
          temperature: options.temperature || 0.3,
          messages: [{
            role: "user",
            content: prompt
          }],
          signal: controller.signal
        });
        
        clearTimeout(timeoutId);
        
        // Validar respuesta
        const summary = response.content[0].text;
        if (this.validateSummary(summary)) {
          return {
            success: true,
            summary: summary,
            tokensUsed: response.usage.total_tokens,
            attempt: attempt
          };
        }
        
        throw new Error('Respuesta no válida');
        
      } catch (error) {
        if (attempt === maxRetries) {
          return {
            success: false,
            error: error.message,
            lastAttempt: attempt
          };
        }
        
        // Esperar antes de reintentar
        await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
      }
    }
  }
  
  validateSummary(summary) {
    return summary && 
           summary.length > 50 && 
           summary.length < 1000 &&
           summary.includes('\n');
  }
}

// Uso en producción
const summarizer = new ArticleSummarizer(anthropic);
const result = await summarizer.generateSummary(articleText, {
  model: "claude-3-opus-20240229",
  maxRetries: 2
});

Errores comunes

1. Prompts monolíticos sin estructura: Enviar todo el texto en un solo bloque sin separar instrucciones del contexto. Solución: Usar templates con marcadores claros y secciones diferenciadas.

2. Falta de manejo de errores robusto: Asumir que la API siempre responde correctamente. Solución: Implementar reintentos con backoff exponencial y timeouts configurables.

3. No medir costos en tiempo real: Usar modelos caros para tareas simples. Solución: Monitorear tokens consumidos y elegir modelos según complejidad.

4. Contextos excesivamente largos: Enviar todo el historial en cada llamada. Solución: Implementar resumen de contexto o ventanas deslizantes.

5. Validación insuficiente de respuestas: Confiar ciegamente en el output de la IA. Solución: Crear validadores específicos por tipo de tarea.

Checklist de dominio

• ✅ Configurar autenticación segura con variables de entorno
• ✅ Diseñar prompt templates reutilizables con marcadores
• ✅ Implementar manejo de errores con reintentos inteligentes
• ✅ Controlar timeouts y cancelar solicitudes lentas
• ✅ Monitorear uso de tokens y costos por operación
• ✅ Validar respuestas antes de procesarlas
• ✅ Versionar y documentar prompts como código

Sistema de Asistente Virtual para Soporte Técnico

Implementa un sistema backend en Python que integre GPT API para responder preguntas de soporte técnico basándose en una base de conocimiento.

1. Crea un archivo tech_support.py con una clase TechSupportAssistant
2. Configura la API de OpenAI usando la biblioteca oficial
3. Diseña un prompt template que incluya:
   • Instrucciones de rol (experto en soporte técnico)
   • Base de conocimiento (documentación de productos)
   • Formato de respuesta esperado (pasos numerados)
   • Limitaciones (no inventar información)
4. Implementa un método answer_question(question, context) que:
   • Combine el template con la pregunta específica
   • Maneje errores de conexión con 2 reintentos
   • Valide que la respuesta contenga pasos accionables
   • Registre tokens utilizados
5. Agrega un método para cargar la base de conocimiento desde un archivo JSON
6. Prueba con al menos 3 preguntas técnicas reales

Pistas

• Usa f-strings para insertar variables en el prompt template
• Implementa un decorador para manejar reintentos automáticamente
• Considera usar un modelo más económico como gpt-3.5-turbo para preguntas simples

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.