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

> Integreer Novita AI met LangChain om intelligente, door taalmodellen aangestuurde applicaties te bouwen. Leer meer over installatie, API-gebruik en workflows voor function calling.

Deze gids begeleidt je door het proces van het integreren van Novita AI met LangChain. Je kunt de krachtige taalmodellen van Novita AI gebruiken met de robuuste tools van LangChain voor het bouwen van door taalmodellen aangestuurde applicaties.

## Wat is LangChain?

LangChain is een framework voor het ontwikkelen van applicaties die worden aangedreven door taalmodellen. Het maakt applicaties mogelijk die:

* **Contextbewust zijn**: LangChain verbindt een taalmodel met contextbronnen (zoals promptinstructies, few-shot-voorbeelden, content waarop het antwoord gebaseerd moet zijn, enz.).
* **Redeneren**: LangChain stelt taalmodellen in staat om te redeneren—of het nu gaat om bepalen hoe ze moeten antwoorden op basis van de aangeleverde context of beslissen welke acties ze moeten uitvoeren.

Met LangChain kun je complexe workflows bouwen, modelgedrag verbeteren met externe kennis en intelligente systemen creëren die dynamisch kunnen communiceren met gebruikers en gegevensbronnen.

## Vereisten

Voordat je begint, zorg ervoor dat je het volgende hebt:

* **Novita AI LLM API-sleutel**:
  * Bezoek [de website van Novita AI](https://novita.ai/) en maak een account aan.
  * Ga na het inloggen naar de pagina [**Key Management**](https://novita.ai/settings/key-management) om je **API-sleutel** te genereren. Deze sleutel is vereist om de modellen van Novita AI met LangChain te verbinden.

    <Frame>
      ![Novita AI-sleutelbeheer](https://mintlify.s3.us-west-1.amazonaws.com/novitaai/images/third-party/dify-1.png)
    </Frame>
* Basiskennis van Node.js, JavaScript en het gebruik van omgevingsvariabelen.

## Integratie

### Stap 1: Stel de API-sleutel in

Stel voor de meeste omgevingen de omgevingsvariabele `NOVITA_API_KEY` als volgt in:

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

Zorg ervoor dat je `your-api-key` vervangt door de daadwerkelijke sleutel die je van Novita AI hebt ontvangen.

### Stap 2: Installeer de vereiste pakketten

Om Novita AI met LangChain te integreren, moet je het pakket `@langchain-community` installeren, dat de Novita AI-integratie bevat.

Kies een van de volgende opdrachten om de benodigde pakketten te installeren:

**Met npm:**

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

**Met yarn:**

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

**Met pnpm:**

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

### Stap 3: Instantieer het Novita AI-model

Zodra je de benodigde pakketten hebt geïnstalleerd, kun je het Novita AI-model instantiëren met behulp van de klasse `ChatNovitaAI`.

Hier is een voorbeeld dat laat zien hoe je dat doet:

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

### Stap 4: Roep het model aan voor chat completion

Zodra het model is geïnstantieerd, kun je het gebruiken om chat completions te genereren door het aan te roepen met een bericht.

Hier is een voorbeeld van hoe je een bericht verzendt en een antwoord ontvangt:

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

### Stap 5: Koppel het model aan prompttemplates

Met LangChain kun je krachtige workflows maken door modellen aan elkaar te koppelen met prompttemplates. Dit kan vooral handig zijn wanneer je dezelfde indeling opnieuw wilt gebruiken voor meerdere invoeren.

Hier is een voorbeeld waarin we het Novita AI-model koppelen aan een aangepaste prompttemplate voor vertalen tussen talen:

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

### Stap 6: Pas de workflow aan

Je kunt de temperature aanpassen, meer berichten toevoegen of andere parameters afstemmen afhankelijk van je use case. LangChain is zeer flexibel en stelt je in staat complexe interacties te ontwerpen door meerdere prompts te koppelen, conditionele logica toe te voegen of met verschillende modellen te werken.

## Function calling met Novita AI en LangChain

Om function calling (of toolgebruik) te implementeren met de LLM API van Novita AI, kan LangChain dienen als een handig framework. In dit voorbeeld maken we een eenvoudige wiskunde-applicatie waarmee het model optel- en vermenigvuldigingsbewerkingen kan uitvoeren via function calls.

💡 Hoewel deze gids LangChain gebruikt voor het gemak, is voor het implementeren van function calling geen specifiek framework vereist. De sleutel is het ontwerpen van de juiste prompts, zodat het model functies begrijpt en correct aanroept. LangChain wordt hier simpelweg gebruikt om de implementatie te stroomlijnen.

### Vereisten

Installeer eerst de vereiste pakketten:

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

### De omgeving instellen

Maak een bestand `.env` aan in de root van je project en voeg je Novita AI API-sleutel toe:

```
NOVITA_API_KEY=your_api_key_here
```

### Implementatiestappen

1. **Definieer de tools**

Laten we eerst twee eenvoudige wiskundige tools maken met behulp van LangChain's `@tool` decorator:

```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. **Maak de functie voor tooluitvoering**

Implementeer vervolgens een functie om de tools uit te voeren:

```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. **Stel de LangChain-pipeline in**

Maak een chain die Novita AI's LLM gebruikt om tool calls te selecteren en voor te bereiden:

```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. **Maak de hoofdverwerkingsfunctie**

Implementeer de hoofdfunctie die wiskundige queries verwerkt:

```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. **Gebruiksvoorbeeld**

Zo gebruik je de implementatie:

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