LangChain

Esta guía te guiará por el proceso de integración de Novita AI con LangChain. Podrás usar los potentes modelos de lenguaje de Novita AI con las sólidas herramientas de LangChain para crear aplicaciones impulsadas por modelos de lenguaje.

¿Qué es LangChain?

LangChain es un framework para desarrollar aplicaciones impulsadas por modelos de lenguaje. Permite crear aplicaciones que:

Son conscientes del contexto: LangChain conecta un modelo de lenguaje con fuentes de contexto (como instrucciones de prompt, ejemplos few-shot, contenido en el que basar su respuesta, etc.).
Razonan: LangChain permite que los modelos de lenguaje razonen, ya sea determinando cómo responder según el contexto proporcionado o decidiendo qué acciones tomar.

Con LangChain, puedes crear flujos de trabajo complejos, mejorar el comportamiento del modelo con conocimiento externo y crear sistemas inteligentes que puedan interactuar dinámicamente con usuarios y fuentes de datos.

Requisitos previos

Antes de empezar, asegúrate de tener lo siguiente:

Clave de API de Novita AI LLM:
- Visita el sitio web de Novita AI y crea una cuenta.
- Después de iniciar sesión, ve a la página de Key Management para generar tu API Key. Esta clave es necesaria para conectar los modelos de Novita AI con LangChain.
Una comprensión básica de Node.js, JavaScript y cómo usar variables de entorno.

Integración

Paso 1: Configura la clave de API

En la mayoría de los entornos, configura la variable de entorno NOVITA_API_KEY de la siguiente manera:

export NOVITA_API_KEY="your-api-key"

Asegúrate de reemplazar your-api-key con la clave real que obtuviste de Novita AI.

Paso 2: Instala los paquetes requeridos

Para integrar Novita AI con LangChain, necesitas instalar el paquete @langchain-community, que incluye la integración con Novita AI. Elige uno de los siguientes comandos para instalar los paquetes necesarios: Usando npm:

npm install @langchain/community @langchain/core

Usando yarn:

yarn add @langchain/community @langchain/core

Usando pnpm:

pnpm add @langchain/community @langchain/core

Paso 3: Instancia el modelo de Novita AI

Una vez que hayas instalado los paquetes necesarios, puedes instanciar el modelo de Novita AI usando la clase ChatNovitaAI. Aquí tienes un ejemplo que demuestra cómo hacerlo:

import { ChatNovitaAI } from "@langchain/community/chat_models/novita";

const llm = new ChatNovitaAI({
  model: "deepseek/deepseek-r1", // You can choose the model you want to use
  temperature: 0, // Optional: Controls randomness. 0 is deterministic.
  // other parameters can be set here...
});

Paso 4: Invoca el modelo para la finalización de chat

Una vez instanciado el modelo, puedes usarlo para generar finalizaciones de chat invocándolo con un mensaje. Aquí tienes un ejemplo de cómo enviar un mensaje y obtener una respuesta:

const aiMsg = await llm.invoke([
  {
    role: "system",
    content: "You are a helpful assistant that translates English to French. Translate the user sentence.",
  },
  {
    role: "human",
    content: "I love programming.",
  },
]);

console.log(aiMsg.content); // The model’s response will be printed here

Paso 5: Encadena el modelo con plantillas de prompt

LangChain te permite crear flujos de trabajo potentes encadenando modelos con plantillas de prompt. Esto puede ser especialmente útil cuando quieres reutilizar el mismo formato para múltiples entradas. Aquí tienes un ejemplo en el que encadenamos el modelo de Novita AI con una plantilla de prompt personalizada para traducir entre idiomas:

import { ChatPromptTemplate } from "@langchain/core/prompts";

// Create a template for translating languages
const prompt = ChatPromptTemplate.fromMessages([
  [
    "system",
    "You are a helpful assistant that translates {input_language} to {output_language}.",
  ],
  ["human", "{input}"],
]);

// Chain the prompt with the model
const chain = prompt.pipe(llm);

// Invoke the chain with inputs for translation
const result = await chain.invoke({
  input_language: "English",
  output_language: "German",
  input: "I love programming.",
});

console.log(result.content); // The translated text will be printed here

Paso 6: Personaliza el flujo de trabajo

Puedes modificar la temperatura, agregar más mensajes o ajustar otros parámetros según tu caso de uso. LangChain es muy flexible, lo que te permite diseñar interacciones complejas encadenando múltiples prompts, agregando lógica condicional o trabajando con diferentes modelos.

Llamada de funciones con Novita AI y LangChain

Para implementar la llamada de funciones (o el uso de herramientas) con la API LLM de Novita AI, LangChain puede servir como un framework conveniente. En este ejemplo, crearemos una aplicación matemática simple que permite al modelo realizar operaciones de suma y multiplicación mediante llamadas de funciones. 💡 Aunque esta guía usa LangChain por comodidad, implementar la llamada de funciones no requiere ningún framework específico. La clave es diseñar los prompts adecuados para que el modelo comprenda e invoque correctamente las funciones. Aquí se usa LangChain simplemente para agilizar la implementación.

Requisitos previos

Primero, instala los paquetes requeridos:

pip install langchain-openai python-dotenv

Configuración del entorno

Crea un archivo .env en la raíz de tu proyecto y agrega tu clave de API de Novita AI:

NOVITA_API_KEY=your_api_key_here

Pasos de implementación

Define las herramientas

Primero, creemos dos herramientas matemáticas simples usando el decorador @tool de LangChain:

from langchain_core.tools import tool

@tool
def multiply(x: float, y: float) -> float:
    """Multiply two numbers together."""
    return x * y

@tool
def add(x: int, y: int) -> int:
    """Add two numbers."""
    return x + y

tools = [multiply, add]

Crea la función de ejecución de herramientas

A continuación, implementa una función para ejecutar las herramientas:

from typing import Any, Dict, Optional, TypedDict
from langchain_core.runnables import RunnableConfig

class ToolCallRequest(TypedDict):
    name: str
    arguments: Dict[str, Any]

def invoke_tool(
    tool_call_request: ToolCallRequest, 
    config: Optional[RunnableConfig] = None
):
    """Execute the specified tool with given arguments."""
    tool_name_to_tool = {tool.name: tool for tool in tools}
    name = tool_call_request["name"]
    requested_tool = tool_name_to_tool[name]
    return requested_tool.invoke(tool_call_request["arguments"], config=config)

Configura el pipeline de LangChain

Crea una cadena que use el LLM de Novita AI para seleccionar y preparar llamadas a herramientas:

from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.tools import render_text_description
import os

def create_chain():
    """Create a chain that uses the specified LLM model to select and prepare tool calls."""
    model = ChatOpenAI(
        model="meta-llama/llama-3.3-70b-instruct",
        api_key=os.getenv("NOVITA_API_KEY"),
        base_url="https://api.novita.ai/openai",
    )
    
    rendered_tools = render_text_description(tools)
    system_prompt = f"""\
    You are an assistant that has access to the following set of tools. 
    Here are the names and descriptions for each tool:

    {rendered_tools}

    Given the user input, return the name and input of the tool to use. 
    Return your response as a JSON blob with 'name' and 'arguments' keys.

    The `arguments` should be a dictionary, with keys corresponding 
    to the argument names and the values corresponding to the requested values.
    """

    prompt = ChatPromptTemplate.from_messages(
        [("system", system_prompt), ("user", "{input}")]
    )

    return prompt | model | JsonOutputParser()

Crea la función principal de procesamiento

Implementa la función principal que procesa consultas matemáticas:

def process_math_query(query: str):
    """Process a mathematical query by using an LLM to select the appropriate tool and execute it."""
    chain = create_chain()
    message = chain.invoke({"input": query})
    result = invoke_tool(message, config=None)
    return message, result

Ejemplo de uso

Así es como se usa la implementación:

if __name__ == "__main__":
    message, result = process_math_query(
        "meta-llama/llama-3.3-70b-instruct", 
        "what's 3 plus 1132"
    )
    print(result)  # Output: 1135

Get started

Model APIs

Agent Sandbox

GPUs

Observability

Resources

¿Qué es LangChain?

Requisitos previos

Integración

Paso 1: Configura la clave de API

Paso 2: Instala los paquetes requeridos

Paso 3: Instancia el modelo de Novita AI

Paso 4: Invoca el modelo para la finalización de chat

Paso 5: Encadena el modelo con plantillas de prompt

Paso 6: Personaliza el flujo de trabajo

Llamada de funciones con Novita AI y LangChain

Requisitos previos

Configuración del entorno

Pasos de implementación

​¿Qué es LangChain?

​Requisitos previos

​Integración

​Paso 1: Configura la clave de API

​Paso 2: Instala los paquetes requeridos

​Paso 3: Instancia el modelo de Novita AI

​Paso 4: Invoca el modelo para la finalización de chat

​Paso 5: Encadena el modelo con plantillas de prompt

​Paso 6: Personaliza el flujo de trabajo

​Llamada de funciones con Novita AI y LangChain

​Requisitos previos

​Configuración del entorno

​Pasos de implementación

¿Qué es LangChain?

Requisitos previos

Integración

Paso 1: Configura la clave de API

Paso 2: Instala los paquetes requeridos

Paso 3: Instancia el modelo de Novita AI

Paso 4: Invoca el modelo para la finalización de chat

Paso 5: Encadena el modelo con plantillas de prompt

Paso 6: Personaliza el flujo de trabajo

Llamada de funciones con Novita AI y LangChain

Requisitos previos

Configuración del entorno

Pasos de implementación