Cerebras — Inferencia LLM Ultra-Rápida

// Caso 1: Consulta legal en tiempo real
// Primer token visible en <200ms

export async function* streamLegalChat(
  query: string,
  history: Message[] = []
) {
  const stream = await cerebras.chat.completions.create({
    model: MODELS.SMART, // 70B para calidad jurídica
    messages: [
      { role: "system", content: SYSTEM_LEGAL },
      ...history,
      { role: "user", content: query },
    ],
    stream: true,
    temperature: 0.3, // baja para precisión legal
    max_tokens: 1500,
  });

  for await (const chunk of stream) {
    const text = chunk.choices[0]?.delta?.content ?? "";
    if (text) yield text; // enviar al cliente vía SSE
  }
}

// Next.js Route Handler (app/api/chat/route.ts)
export async function POST(req: Request) {
  const { query, history } = await req.json();
  const encoder = new TextEncoder();
  const stream = streamLegalChat(query, history);

  return new Response(
    new ReadableStream({
      async start(ctrl) {
        for await (const token of stream)
          ctrl.enqueue(encoder.encode(token));
        ctrl.close();
      }
    }),
    { headers: { "Content-Type": "text/plain; charset=utf-8" } }
  );
}

// Caso 2: Extraer cláusulas de un contrato
// Target: <500ms para contratos <8000 tokens

interface ClausulasContrato {
  partes: { empleador: string; empleado: string };
  duracion: string;
  salario_bruto_anual: number;
  clausulas_criticas: string[];
  riesgos_detectados: string[];
}

export async function extraerClausulas(
  textoContrato: string
): Promise<ClausulasContrato> {
  const resp = await cerebras.chat.completions.create({
    model: MODELS.CONTEXT, // 128K ctx para contratos largos
    messages: [{
      role: "user",
      content: `Extrae en JSON las cláusulas del contrato:\n\n${textoContrato}`
    }],
    response_format: { type: "json_object" }, // salida garantizada
    temperature: 0, // determinístico para extracción
  });

  return JSON.parse(
    resp.choices[0].message.content!
  );
}

// Ejemplo de output real para contrato laboralDemo
// {
// partes: { empleador: "FirmaJurídicaMadrid SL", empleado: "Juan García" },
// duracion: "indefinido",
// salario_bruto_anual: 38000,
// clausulas_criticas: ["No competencia 2 años", "Confidencialidad perpetua"],
// riesgos_detectados: ["Cláusula no-competencia puede ser nula (ET art.21)"]
// }

# Caso 3: Clasificar urgencia de consultas entrantes
# Usa llama3.1-8b — ~2500 tok/s, total <200ms

from openai import OpenAI
import json, os

client = OpenAI(
  api_key=os.environ["CEREBRAS_API_KEY"],
  base_url="https://api.cerebras.ai/v1"
)

def clasificar_urgencia(consulta: str) -> dict:
  resp = client.chat.completions.create(
    model="llama3.1-8b", # 8B suficiente para clasificación
    messages=[{
      "role": "user",
      "content": f"""Clasifica en JSON la consulta legal:
        urgencia: "alta"|"media"|"baja"
        area: "laboral"|"contratos"|"mercantil"|"otro"
        requiere_abogado: true|false
        Consulta: {consulta}"""
    }],
    response_format={"type": "json_object"},
    max_tokens=80, # clasificación corta
    temperature=0
  )
  return json.loads(resp.choices[0].message.content)

# Test real:
# clasificar_urgencia("Me han despedido sin carta y sin preaviso")
# → {"urgencia":"alta","area":"laboral","requiere_abogado":true}
# Tiempo total: ~180ms ✓

// Caso 4: Tool calling para buscar jurisprudencia en BD interna

const TOOLS: OpenAI.Tool[] = [{
  type: "function",
  function: {
    name: "buscar_jurisprudencia",
    description: "Busca sentencias del TS/AN sobre un tema",
    parameters: {
      type: "object",
      properties: {
        keywords: { type: "string" },
        tribunal: { type: "string", enum: ["TS","AN","TSJ"] },
        anyo_desde: { type: "number" },
      },
      required: ["keywords"]
    }
  }
}];

export async function consultarConJurisprudencia(query: string) {
  const r1 = await cerebras.chat.completions.create({
    model: MODELS.SMART,
    messages: [{ role: "user", content: query }],
    tools: TOOLS, tool_choice: "auto"
  });

  const msg = r1.choices[0].message;
  if (!msg.tool_calls) return msg.content;

  // Ejecutar búsqueda real en BD PostgreSQL
  const args = JSON.parse(msg.tool_calls[0].function.arguments);
  const sentencias = await buscarEnBD(args);

  // Respuesta final con contexto de jurisprudencia
  const r2 = await cerebras.chat.completions.create({
    model: MODELS.SMART,
    messages: [
      { role: "user", content: query }, msg,
      { role: "tool", tool_call_id: msg.tool_calls[0].id,
        content: JSON.stringify(sentencias) }
    ],
  });
  return r2.choices[0].message.content;
}