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

> Integrieren Sie Novita AI mit LangChain, um intelligente, sprachmodellgesteuerte Anwendungen zu erstellen. Erfahren Sie mehr über Einrichtung, API-Nutzung und Workflows für Funktionsaufrufe.

Diese Anleitung führt Sie durch den Prozess der Integration von Novita AI mit LangChain. Sie können die leistungsstarken Sprachmodelle von Novita AI mit den robusten Tools von LangChain zum Erstellen sprachmodellgesteuerter Anwendungen verwenden.

## Was ist LangChain?

LangChain ist ein Framework zur Entwicklung von Anwendungen, die von Sprachmodellen unterstützt werden. Es ermöglicht Anwendungen, die:

* **Kontextbewusst sind**: LangChain verbindet ein Sprachmodell mit Kontextquellen (z. B. Prompt-Anweisungen, Few-Shot-Beispiele, Inhalte, auf denen die Antwort basieren soll usw.).
* **Schlussfolgern**: LangChain ermöglicht es Sprachmodellen, zu schlussfolgern – sei es, um anhand des bereitgestellten Kontexts zu bestimmen, wie geantwortet werden soll, oder um zu entscheiden, welche Aktionen ausgeführt werden sollen.

Mit LangChain können Sie komplexe Workflows erstellen, das Modellverhalten durch externes Wissen verbessern und intelligente Systeme entwickeln, die dynamisch mit Benutzern und Datenquellen interagieren können.

## Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

* **Novita AI LLM-API-Schlüssel**:
  * Besuchen Sie die [Website von Novita AI](https://novita.ai/) und erstellen Sie ein Konto.
  * Gehen Sie nach der Anmeldung zur Seite [**Schlüsselverwaltung**](https://novita.ai/settings/key-management), um Ihren **API Key** zu generieren. Dieser Schlüssel ist erforderlich, um die Modelle von Novita AI mit LangChain zu verbinden.

    <Frame>
      ![Novita AI Schlüsselverwaltung](https://mintlify.s3.us-west-1.amazonaws.com/novitaai/images/third-party/dify-1.png)
    </Frame>
* Ein grundlegendes Verständnis von Node.js, JavaScript und der Verwendung von Umgebungsvariablen.

## Integration

### Schritt 1: API-Schlüssel festlegen

Legen Sie für die meisten Umgebungen die Umgebungsvariable `NOVITA_API_KEY` wie folgt fest:

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

Stellen Sie sicher, dass Sie `your-api-key` durch den tatsächlichen Schlüssel ersetzen, den Sie von Novita AI erhalten haben.

### Schritt 2: Erforderliche Pakete installieren

Um Novita AI mit LangChain zu integrieren, müssen Sie das Paket `@langchain-community` installieren, das die Novita AI-Integration enthält.

Wählen Sie einen der folgenden Befehle aus, um die erforderlichen Pakete zu installieren:

**Mit npm:**

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

**Mit yarn:**

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

**Mit pnpm:**

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

### Schritt 3: Novita AI-Modell instanziieren

Nachdem Sie die erforderlichen Pakete installiert haben, können Sie das Novita AI-Modell mithilfe der Klasse `ChatNovitaAI` instanziieren.

Hier ist ein Beispiel, das zeigt, wie das funktioniert:

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

### Schritt 4: Modell für Chat Completion aufrufen

Sobald das Modell instanziiert ist, können Sie es verwenden, um Chat Completions zu generieren, indem Sie es mit einer Nachricht aufrufen.

Hier ist ein Beispiel dafür, wie Sie eine Nachricht senden und eine Antwort erhalten:

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

### Schritt 5: Modell mit Prompt-Vorlagen verketten

LangChain ermöglicht es Ihnen, leistungsstarke Workflows zu erstellen, indem Sie Modelle mit Prompt-Vorlagen verketten. Dies ist besonders nützlich, wenn Sie dasselbe Format für mehrere Eingaben wiederverwenden möchten.

Hier ist ein Beispiel, in dem wir das Novita AI-Modell mit einer benutzerdefinierten Prompt-Vorlage für Übersetzungen zwischen Sprachen verketten:

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

### Schritt 6: Workflow anpassen

Sie können die Temperatur ändern, weitere Nachrichten hinzufügen oder andere Parameter je nach Anwendungsfall anpassen. LangChain ist äußerst flexibel und ermöglicht Ihnen, komplexe Interaktionen zu entwerfen, indem Sie mehrere Prompts verketten, bedingte Logik hinzufügen oder mit verschiedenen Modellen arbeiten.

## Funktionsaufrufe mit Novita AI und LangChain

Um Function Calling (oder Tool-Nutzung) mit der LLM API von Novita AI zu implementieren, kann LangChain als praktisches Framework dienen. In diesem Beispiel erstellen wir eine einfache Mathematikanwendung, mit der das Modell Additions- und Multiplikationsoperationen über Funktionsaufrufe ausführen kann.

💡 Obwohl diese Anleitung der Einfachheit halber LangChain verwendet, erfordert die Implementierung von Funktionsaufrufen kein bestimmtes Framework. Entscheidend ist, die richtigen Prompts zu entwerfen, damit das Modell Funktionen versteht und korrekt aufruft. LangChain wird hier lediglich verwendet, um die Implementierung zu vereinfachen.

### Voraussetzungen

Installieren Sie zunächst die erforderlichen Pakete:

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

### Umgebung einrichten

Erstellen Sie eine Datei `.env` im Stammverzeichnis Ihres Projekts und fügen Sie Ihren Novita AI-API-Schlüssel hinzu:

```
NOVITA_API_KEY=your_api_key_here
```

### Implementierungsschritte

1. **Tools definieren**

Erstellen wir zunächst zwei einfache mathematische Tools mit dem Decorator `@tool` von 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. **Tool-Ausführungsfunktion erstellen**

Implementieren Sie als Nächstes eine Funktion zum Ausführen der Tools:

```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. **LangChain-Pipeline einrichten**

Erstellen Sie eine Chain, die das LLM von Novita AI verwendet, um Tool-Aufrufe auszuwählen und vorzubereiten:

```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. **Hauptverarbeitungsfunktion erstellen**

Implementieren Sie die Hauptfunktion, die mathematische Abfragen verarbeitet:

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

So verwenden Sie die Implementierung:

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