¿Para tu próximo proyecto con IA, qué prefieres usar?

import OpenAI from 'openai';
 
const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});
 
async function generarRespuesta(prompt) {
  const completion = await openai.chat.completions.create({
    model: "gpt-4-turbo-preview",
    messages: [
      { role: "system", content: "Eres un asistente experto en programación." },
      { role: "user", content: prompt }
    ],
    temperature: 0.7,
    max_tokens: 1000,
  });
 
  return completion.choices[0].message.content;
}
 
// Uso
const respuesta = await generarRespuesta("Explica qué son las closures en JavaScript");
console.log(respuesta);

import Anthropic from '@anthropic-ai/sdk';
 
const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});
 
async function chatConClaude(mensaje) {
  const message = await anthropic.messages.create({
    model: "claude-3-5-sonnet-20241022",
    max_tokens: 1024,
    messages: [
      { role: "user", content: mensaje }
    ],
  });
 
  return message.content[0].text;
}
 
// Perfecto para análisis de código
const analisis = await chatConClaude(`
  Analiza este código y sugiere mejoras:
  
  function fetchData() {
    var result;
    $.ajax({
      url: '/api/data',
      async: false,
      success: function(data) {
        result = data;
      }
    });
    return result;
  }
`);

// Puedes pasar archivos enteros para análisis
async function analizarRepositorio(archivos) {
  const contenidoCompleto = archivos
    .map(f => `// ${f.path}\n${f.content}`)
    .join('\n\n');
  
  const analisis = await chatConClaude(`
    Analiza esta base de código y encuentra:
    1. Problemas de seguridad
    2. Code smells
    3. Oportunidades de refactoring
    
    ${contenidoCompleto}
  `);
  
  return analisis;
}

// Usando Ollama (la forma más fácil de correr modelos locales)
import { Ollama } from 'ollama';
 
const ollama = new Ollama();
 
async function chatLocal(prompt) {
  const response = await ollama.chat({
    model: 'llama3.1',
    messages: [{ role: 'user', content: prompt }],
  });
  
  return response.message.content;
}
 
// Gratis, pero necesitas hardware decente
const respuesta = await chatLocal("Genera un README para un proyecto de React");

import Replicate from 'replicate';
 
const replicate = new Replicate({
  auth: process.env.REPLICATE_API_TOKEN,
});
 
async function usarLlama(prompt) {
  const output = await replicate.run(
    "meta/llama-2-70b-chat:latest",
    {
      input: {
        prompt: prompt,
        max_tokens: 500,
      }
    }
  );
  
  return output.join('');
}

// app/api/chat/route.js
import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';
 
export async function POST(req) {
  const { messages } = await req.json();
 
  const result = await streamText({
    model: openai('gpt-4-turbo'),
    messages,
  });
 
  return result.toAIStreamResponse();
}
 
// En tu componente React
import { useChat } from 'ai/react';
 
export default function Chat() {
  const { messages, input, handleInputChange, handleSubmit } = useChat();
 
  return (
    <div>
      {messages.map(m => (
        <div key={m.id}>
          <strong>{m.role}:</strong> {m.content}
        </div>
      ))}
      
      <form onSubmit={handleSubmit}>
        <input value={input} onChange={handleInputChange} />
        <button type="submit">Enviar</button>
      </form>
    </div>
  );
}

async function soporteCliente(pregunta, historial) {
  const contexto = `
    Eres un asistente de soporte para una plataforma de e-commerce.
    Base de conocimiento: [FAQ, políticas, procedimientos]
  `;
  
  const mensajes = [
    { role: "system", content: contexto },
    ...historial,
    { role: "user", content: pregunta }
  ];
  
  // Claude es mejor para seguir instrucciones complejas
  return await chatConClaude(mensajes);
}

async function generarComponente(descripcion) {
  // GPT-4 para la estructura inicial
  const estructura = await generarRespuesta(`
    Genera un componente React para: ${descripcion}
  `);
  
  // Claude para revisar y optimizar
  const optimizado = await chatConClaude(`
    Revisa este código y optimízalo:
    ${estructura}
  `);
  
  return optimizado;
}

async function analizarCSV(datos) {
  const prompt = `
    Analiza estos datos de ventas y dame insights:
    ${JSON.stringify(datos.slice(0, 100))}
    
    Busca patrones, anomalías y tendencias.
  `;
  
  // Open source es suficiente para análisis
  return await usarLlama(prompt);
}

import OpenAI from 'openai';
 
const openai = new OpenAI();
 
async function crearEmbeddings(textos) {
  const response = await openai.embeddings.create({
    model: "text-embedding-3-small",
    input: textos,
  });
  
  return response.data.map(d => d.embedding);
}
 
// Buscar documentos similares
async function buscarSimilar(query, documentos) {
  const queryEmbedding = await crearEmbeddings([query]);
  
  // Calcula similitud coseno con tus documentos
  const similitudes = documentos.map(doc => 
    cosineSimilarity(queryEmbedding[0], doc.embedding)
  );
  
  return documentos[similitudes.indexOf(Math.max(...similitudes))];
}