> ## Documentation Index
> Fetch the complete documentation index at: https://novita.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# LangChain

> Integra Novita AI con LangChain para crear aplicaciones inteligentes impulsadas por modelos de lenguaje. Aprende la configuración, el uso de la API y los flujos de trabajo de llamada de funciones.

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](https://novita.ai/) y crea una cuenta.
  * Después de iniciar sesión, ve a la página de [**Key Management**](https://novita.ai/settings/key-management) para generar tu **API Key**. Esta clave es necesaria para conectar los modelos de Novita AI con LangChain.

    <Frame>
      ![Gestión de claves de Novita AI](https://mintlify.s3.us-west-1.amazonaws.com/novitaai/images/third-party/dify-1.png)
    </Frame>
* 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:

```bash theme={"system"}
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:**

```bash theme={"system"}
npm install @langchain/community @langchain/core
```

**Usando yarn:**

```bash theme={"system"}
yarn add @langchain/community @langchain/core
```

**Usando pnpm:**

```bash theme={"system"}
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:

```javascript theme={"system"}
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:

```javascript theme={"system"}
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:

```javascript theme={"system"}
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:

```bash theme={"system"}
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

1. **Define las herramientas**

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

```python theme={"system"}
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]
```

2. **Crea la función de ejecución de herramientas**

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

```python theme={"system"}
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)
```

3. **Configura el pipeline de LangChain**

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

```python theme={"system"}
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()
```

4. **Crea la función principal de procesamiento**

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

```python theme={"system"}
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
```

5. **Ejemplo de uso**

Así es como se usa la implementación:

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