> ## 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

> Intégrez Novita AI à LangChain pour créer des applications intelligentes pilotées par des modèles de langage. Découvrez la configuration, l’utilisation de l’API et les workflows d’appel de fonctions.

Ce guide vous accompagnera dans le processus d’intégration de Novita AI avec LangChain. Vous pourrez utiliser les puissants modèles de langage de Novita AI avec les outils robustes de LangChain pour créer des applications pilotées par des modèles de langage.

## Qu’est-ce que LangChain ?

LangChain est un framework pour développer des applications alimentées par des modèles de langage. Il permet de créer des applications qui :

* **Sont conscientes du contexte** : LangChain connecte un modèle de langage à des sources de contexte (comme des instructions de prompt, des exemples few-shot, du contenu sur lequel ancrer sa réponse, etc.).
* **Raisonnent** : LangChain permet aux modèles de langage de raisonner, qu’il s’agisse de déterminer comment répondre en fonction du contexte fourni ou de décider quelles actions entreprendre.

Avec LangChain, vous pouvez créer des workflows complexes, améliorer le comportement des modèles avec des connaissances externes et créer des systèmes intelligents capables d’interagir dynamiquement avec les utilisateurs et les sources de données.

## Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

* **Clé API Novita AI LLM** :
  * Visitez le [site web de Novita AI](https://novita.ai/) et créez un compte.
  * Après vous être connecté, accédez à la page [**Key Management**](https://novita.ai/settings/key-management) pour générer votre **API Key**. Cette clé est nécessaire pour connecter les modèles de Novita AI à LangChain.

    <Frame>
      ![Gestion des clés Novita AI](https://mintlify.s3.us-west-1.amazonaws.com/novitaai/images/third-party/dify-1.png)
    </Frame>
* Une compréhension de base de Node.js, de JavaScript et de l’utilisation des variables d’environnement.

## Intégration

### Étape 1 : définir la clé API

Pour la plupart des environnements, définissez la variable d’environnement `NOVITA_API_KEY` comme suit :

```bash theme={"system"}
export NOVITA_API_KEY="your-api-key"
```

Veillez à remplacer `your-api-key` par la clé réelle que vous avez obtenue auprès de Novita AI.

### Étape 2 : installer les packages requis

Pour intégrer Novita AI à LangChain, vous devez installer le package `@langchain-community`, qui inclut l’intégration Novita AI.

Choisissez l’une des commandes suivantes pour installer les packages nécessaires :

**Avec npm :**

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

**Avec yarn :**

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

**Avec pnpm :**

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

### Étape 3 : instancier le modèle Novita AI

Une fois les packages nécessaires installés, vous pouvez instancier le modèle Novita AI à l’aide de la classe `ChatNovitaAI`.

Voici un exemple qui montre comment faire :

```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...
});
```

### Étape 4 : invoquer le modèle pour la complétion de chat

Une fois le modèle instancié, vous pouvez l’utiliser pour générer des complétions de chat en l’invoquant avec un message.

Voici un exemple montrant comment envoyer un message et obtenir une réponse :

```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
```

### Étape 5 : chaîner le modèle avec des modèles de prompt

LangChain vous permet de créer des workflows puissants en chaînant des modèles avec des modèles de prompt. Cela peut être particulièrement utile lorsque vous souhaitez réutiliser le même format pour plusieurs entrées.

Voici un exemple dans lequel nous chaînons le modèle Novita AI avec un modèle de prompt personnalisé pour traduire entre différentes langues :

```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
```

### Étape 6 : personnaliser le workflow

Vous pouvez modifier la température, ajouter davantage de messages ou ajuster d’autres paramètres selon votre cas d’utilisation. LangChain est très flexible et vous permet de concevoir des interactions complexes en chaînant plusieurs prompts, en ajoutant une logique conditionnelle ou en travaillant avec différents modèles.

## Appel de fonctions avec Novita AI et LangChain

Pour implémenter l’appel de fonctions (ou l’utilisation d’outils) avec l’API LLM de Novita AI, LangChain peut servir de framework pratique. Dans cet exemple, nous allons créer une application mathématique simple qui permet au modèle d’effectuer des opérations d’addition et de multiplication via des appels de fonctions.

💡 Bien que ce guide utilise LangChain par commodité, l’implémentation de l’appel de fonctions ne nécessite aucun framework spécifique. L’élément clé consiste à concevoir les bons prompts pour que le modèle comprenne et invoque correctement les fonctions. LangChain est utilisé ici simplement pour simplifier l’implémentation.

### Prérequis

Commencez par installer les packages requis :

```bash theme={"system"}
pip install langchain-openai python-dotenv
```

### Configurer l’environnement

Créez un fichier `.env` à la racine de votre projet et ajoutez votre clé API Novita AI :

```
NOVITA_API_KEY=your_api_key_here
```

### Étapes d’implémentation

1. **Définir les outils**

Commençons par créer deux outils mathématiques simples à l’aide du décorateur `@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. **Créer la fonction d’exécution des outils**

Ensuite, implémentez une fonction pour exécuter les outils :

```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. **Configurer le pipeline LangChain**

Créez une chaîne qui utilise le LLM de Novita AI pour sélectionner et préparer les appels d’outils :

```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. **Créer la fonction principale de traitement**

Implémentez la fonction principale qui traite les requêtes mathématiques :

```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. **Exemple d’utilisation**

Voici comment utiliser l’implémentation :

```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
```