2025-03-02

OpenAI ofrece una API potente para integrar modelos de inteligencia artificial en aplicaciones web y móviles. Con Node.js y Express, los desarrolladores pueden crear servicios que interactúen con modelos como GPT-4 para generar texto, realizar análisis semántico, resumir documentos y mucho más.

Este artículo explica en detalle cómo conectarse a la API de OpenAI usando Node.js con Express, incluyendo la instalación, configuración, validación del prompt, uso de endpoints y consideraciones sobre costos.

 

Prerrequisitos

Antes de comenzar, asegúrate de tener:

• Node.js instalado (versión 16 o superior recomendada).
• Express.js como framework para manejar las peticiones.
• Una clave API de OpenAI, obtenida desde OpenAI Developers.
• Postman o Curl para probar la API (opcional).

 

Instalación y Configuración del Proyecto

Paso 1: Crear un Proyecto Node.js

Abre una terminal y crea un nuevo proyecto:

mkdir openai-express-api
cd openai-express-api
npm init -y

Esto generará un archivo package.json con la configuración básica del proyecto.

 

Paso 2: Instalar Dependencias

Ejecuta el siguiente comando para instalar los paquetes necesarios:

npm install express dotenv openai cors body-parser

• express: Framework web para manejar peticiones HTTP.
• dotenv: Manejo de variables de entorno.
• openai: Cliente oficial para la API de OpenAI.
• cors: Permite solicitudes desde diferentes dominios.
• body-parser: Facilita el manejo de datos en las peticiones.

 

Paso 3: Configurar Variables de Entorno

Crea un archivo .env en la raíz del proyecto y añade:

OPENAI_API_KEY=tu_clave_de_openai
PORT=5000

Esto mantendrá la clave API protegida y facilitará la configuración del puerto del servidor.

 

 

3. Creando un Servidor Express con Validación de Prompt

 

Crea un archivo server.js y agrega el siguiente código con validación del prompt antes de enviarlo a OpenAI:

 

require('dotenv').config();
const express = require('express');
const cors = require('cors');
const bodyParser = require('body-parser');
const { OpenAI } = require('openai');

const app = express();
const port = process.env.PORT || 5000;

app.use(cors());
app.use(bodyParser.json());

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// Función para validar el prompt
const validatePrompt = (prompt) => {
    if (!prompt || typeof prompt !== 'string' || prompt.length < 5) {
        return "El prompt debe ser un texto válido con al menos 5 caracteres.";
    }
    if (prompt.length > 500) {
        return "El prompt es demasiado largo. Máximo 500 caracteres permitidos.";
    }
    return null;
};

// Endpoint para interactuar con OpenAI
app.post('/chat', async (req, res) => {
    try {
        const { prompt } = req.body;
        const error = validatePrompt(prompt);
        if (error) {
            return res.status(400).json({ error });
        }

        const response = await openai.chat.completions.create({
            model: "gpt-4",
            messages: [{ role: "user", content: prompt }],
            temperature: 0.7,
            max_tokens: 200,
            top_p: 0.9,
            n: 1
        });

        res.json({ response: response.choices[0].message.content });
    } catch (error) {
        console.error(error);
        res.status(500).json({ error: "Error en la comunicación con OpenAI" });
    }
});

app.listen(port, () => {
    console.log(`Servidor corriendo en http://localhost:${port}`);
});

 

Este servidor ahora:

• Valida el prompt antes de enviarlo a OpenAI, asegurando que sea un texto válido y que no exceda los límites definidos.
• Recibe una solicitud POST en el endpoint /chat.
• Envía el prompt validado a la API de OpenAI.
• Retorna la respuesta generada por el modelo.

 

 

Probando la API

 

Prueba con Postman o Curl

En Postman, crea una solicitud POST a http://localhost:5000/chat con el siguiente body JSON:

{
    "prompt": "Explica qué es la computación cuántica"
}

Si todo está configurado correctamente, recibirás una respuesta válida.

Si el prompt es demasiado corto, recibirás un error como:

{
    "error": "El prompt debe ser un texto válido con al menos 5 caracteres."
}

 

Atributos y Parametros Clave

En el código proporcionado para conectarse a la API de OpenAI con Node.js y Express, hay varios atributos y parámetros clave que afectan el tipo de respuesta que se recibe. Estos atributos permiten ajustar la precisión, creatividad y formato de la respuesta generada. A continuación, explico cada uno de ellos desde el punto de vista de programación:

 

1. Modelo de lenguaje utilizado (model)

const response = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [{ role: "user", content: prompt }],
    temperature: 0.7,
});

• Propósito: Define qué versión del modelo de OpenAI se utilizará.
• Opciones comunes: "gpt-4", "gpt-3.5-turbo".
• Impacto: Modelos más avanzados como gpt-4 proporcionan respuestas más precisas y contextuales, pero también son más costosos.

 

2. Temperatura (temperature)

temperature: 0.7

• Propósito: Controla la creatividad de la respuesta.
• Valores típicos:
  • 0.1 - 0.3: Respuestas más deterministas y precisas (útil para datos técnicos o respuestas exactas).
  • 0.7 - 1.0: Respuestas más variadas y creativas (útil para generación de contenido, historias, ideas).
• Ejemplo de comparación:
  • temperature: 0.1 → Respuesta más objetiva y repetitiva.
  • temperature: 0.9 → Respuesta más diversa y original.

 

3. Mensajes (messages)

messages: [{ role: "user", content: prompt }]

• Propósito: Define el contexto de la conversación. OpenAI usa un historial de mensajes en formato de lista.
• Roles posibles:
  • "system": Define reglas para el modelo. Ejemplo: "Eres un asistente técnico especializado en Node.js."
  • "user": Contiene la pregunta del usuario.
  • "assistant": Guarda las respuestas previas del modelo.
• Ejemplo con contexto adicional:

  messages: [
      { role: "system", content: "Eres un bot experto en seguridad informática." },
      { role: "user", content: "¿Cómo puedo proteger una API en Express?" }
  ]
  

  Esto hace que el modelo adopte un rol más específico en sus respuestas.

 

Número de tokens de respuesta (max_tokens)

max_tokens: 100

• Propósito: Limita la cantidad de palabras en la respuesta generada.
• Valores recomendados:
  • 50-100 tokens: Respuestas cortas y concisas.
  • 200-500 tokens: Respuestas detalladas.
  • 1000+ tokens: Explicaciones extensas (cuidado con costos y tiempo de respuesta).
• Impacto: Reducir max_tokens puede ayudar a controlar los costos y mantener respuestas breves.

 

Diversidad de palabras (top_p)

top_p: 0.9

• Propósito: Método de muestreo para controlar qué palabras son elegidas en la respuesta.
• Diferencia con temperature:
  • top_p filtra opciones menos probables en la generación de palabras.
  • temperature ajusta la aleatoriedad general de la respuesta.
• Valores recomendados:
  • 0.1 - 0.5: Respuestas más directas y precisas.
  • 0.7 - 1.0: Más diversidad y creatividad.

 

Elección de respuesta óptima (n)

n: 3

• Propósito: Define cuántas respuestas genera el modelo antes de seleccionar una.
• Valores recomendados:
  • 1: Solo genera una respuesta (eficiente en costos).
  • 3-5: Genera varias respuestas y permite elegir la mejor.
• Ejemplo de implementación: Obtener 3 respuestas diferentes y seleccionar la más adecuada.

  const response = await openai.chat.completions.create({
      model: "gpt-4",
      messages: [{ role: "user", content: "Dame ideas para un negocio de IA." }],
      temperature: 0.8,
      n: 3
  });
  
  console.log(response.choices.map(choice => choice.message.content));
  

  Esto devuelve 3 ideas de negocio y el usuario puede elegir la más relevante.

 

Consideraciones sobre Configuración y Costos

 

Parámetros de Configuración Ajustados

• temperature: 0.7 → Equilibra creatividad y precisión.
• max_tokens: 200 → Limita la respuesta para evitar respuestas demasiado largas y costosas.
• top_p: 0.9 → Controla la diversidad de la respuesta.

 

Costos Aproximados

Modelo	Precio por 1,000 tokens (entrada)	Precio por 1,000 tokens (salida)
GPT-4	$0.03	$0.06
GPT-3.5	$0.0015	$0.0020

 

Para optimizar costos:

• Usar max_tokens bajo para respuestas concisas.
• Seleccionar modelos más baratos como gpt-3.5 si la precisión extrema no es necesaria.

 

Últimas publicaciones