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

> Integre a Novita AI ao LangChain para criar aplicações inteligentes orientadas por modelos de linguagem. Aprenda sobre configuração, uso da API e fluxos de trabalho de chamada de função.

Este guia mostrará o processo de integração da Novita AI com o LangChain. Você poderá usar os poderosos modelos de linguagem da Novita AI com as ferramentas robustas do LangChain para criar aplicações orientadas por modelos de linguagem.

## O que é LangChain?

LangChain é um framework para desenvolver aplicações impulsionadas por modelos de linguagem. Ele possibilita aplicações que:

* **São conscientes de contexto**: o LangChain conecta um modelo de linguagem a fontes de contexto (como instruções de prompt, exemplos few-shot, conteúdo no qual fundamentar a resposta etc.).
* **Raciocinam**: o LangChain permite que modelos de linguagem raciocinem — seja determinando como responder com base no contexto fornecido ou decidindo quais ações tomar.

Com o LangChain, você pode criar fluxos de trabalho complexos, melhorar o comportamento do modelo com conhecimento externo e criar sistemas inteligentes que interagem dinamicamente com usuários e fontes de dados.

## Pré-requisitos

Antes de começar, certifique-se de ter o seguinte:

* **Chave de API LLM da Novita AI**:
  * Acesse o [site da Novita AI](https://novita.ai/) e crie uma conta.
  * Após fazer login, vá para a página [**Key Management**](https://novita.ai/settings/key-management) para gerar sua **API Key**. Essa chave é necessária para conectar os modelos da Novita AI ao LangChain.

    <Frame>
      ![Gerenciamento de chaves da Novita AI](https://mintlify.s3.us-west-1.amazonaws.com/novitaai/images/third-party/dify-1.png)
    </Frame>
* Uma compreensão básica de Node.js, JavaScript e de como usar variáveis de ambiente.

## Integração

### Etapa 1: Definir a chave de API

Para a maioria dos ambientes, defina a variável de ambiente `NOVITA_API_KEY` da seguinte forma:

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

Certifique-se de substituir `your-api-key` pela chave real que você obteve da Novita AI.

### Etapa 2: Instalar os pacotes necessários

Para integrar a Novita AI ao LangChain, você precisa instalar o pacote `@langchain-community`, que inclui a integração com a Novita AI.

Escolha um dos comandos a seguir para instalar os pacotes necessários:

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

### Etapa 3: Instanciar o modelo da Novita AI

Depois de instalar os pacotes necessários, você pode instanciar o modelo da Novita AI usando a classe `ChatNovitaAI`.

Aqui está um exemplo que demonstra como fazer isso:

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

### Etapa 4: Invocar o modelo para conclusão de chat

Depois que o modelo estiver instanciado, você poderá usá-lo para gerar conclusões de chat invocando-o com uma mensagem.

Aqui está um exemplo de como enviar uma mensagem e obter uma resposta:

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

### Etapa 5: Encadear o modelo com templates de prompt

O LangChain permite criar fluxos de trabalho poderosos encadeando modelos com templates de prompt. Isso pode ser especialmente útil quando você quer reutilizar o mesmo formato para várias entradas.

Aqui está um exemplo em que encadeamos o modelo da Novita AI com um template de prompt personalizado para traduzir 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
```

### Etapa 6: Personalizar o fluxo de trabalho

Você pode modificar a temperatura, adicionar mais mensagens ou ajustar outros parâmetros dependendo do seu caso de uso. O LangChain é altamente flexível, permitindo que você projete interações complexas encadeando múltiplos prompts, adicionando lógica condicional ou trabalhando com diferentes modelos.

## Chamada de função com Novita AI e LangChain

Para implementar chamada de função (ou uso de ferramentas) com a API LLM da Novita AI, o LangChain pode servir como um framework conveniente. Neste exemplo, criaremos uma aplicação matemática simples que permite ao modelo realizar operações de adição e multiplicação por meio de chamadas de função.

💡 Embora este guia use o LangChain por conveniência, implementar chamada de função não exige nenhum framework específico. O ponto principal é projetar os prompts corretos para fazer o modelo entender e invocar funções corretamente. O LangChain é usado aqui simplesmente para simplificar a implementação.

### Pré-requisitos

Primeiro, instale os pacotes necessários:

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

### Configurando o ambiente

Crie um arquivo `.env` na raiz do seu projeto e adicione sua chave de API da Novita AI:

```
NOVITA_API_KEY=your_api_key_here
```

### Etapas de implementação

1. **Definir as ferramentas**

Primeiro, vamos criar duas ferramentas matemáticas simples usando o decorador `@tool` do 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. **Criar a função de execução das ferramentas**

Em seguida, implemente uma função para executar as ferramentas:

```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. **Configurar o pipeline do LangChain**

Crie uma chain que usa o LLM da Novita AI para selecionar e preparar chamadas de ferramentas:

```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. **Criar a função principal de processamento**

Implemente a função principal que processa 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. **Exemplo de uso**

Veja como usar a implementação:

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