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

# Integração com LlamaIndex

> Construa pipelines RAG, agentes e query engines com o LlamaIndex usando os modelos de chat e embeddings privados e compatíveis com OpenAI da Venice por meio do cliente OpenAILike.

O [LlamaIndex](https://www.llamaindex.ai/) é um framework de dados para construir pipelines RAG, agentes e query engines sobre seus próprios dados. A Venice funciona como um backend compatível com OpenAI — aponte os clientes de LLM e embeddings `OpenAILike` para a base URL da Venice e continue usando o restante da API do LlamaIndex normalmente.

## Pré-requisitos

* Python 3.9 ou superior
* Uma [chave de API da Venice](/guides/getting-started/generating-api-key)

## Configuração

Instale o LlamaIndex com as integrações de LLM e embeddings compatíveis com OpenAI:

<CodeGroup>
  ```bash pip theme={"system"}
  pip install llama-index llama-index-llms-openai-like llama-index-embeddings-openai-like
  ```

  ```bash uv theme={"system"}
  uv add llama-index llama-index-llms-openai-like llama-index-embeddings-openai-like
  ```
</CodeGroup>

Adicione sua chave de API da Venice ao ambiente:

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

<Warning>
  Mantenha as chaves de API fora do controle de versão. Prefira variáveis de ambiente ou um gerenciador de segredos em produção.
</Warning>

## Configure a Venice como LLM

A Venice fala a API Chat Completions da OpenAI. Use `OpenAILike` com a base URL da Venice e defina `is_chat_model=True`:

```python theme={"system"}
import os

from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    model="venice-uncensored",
    api_base="https://api.venice.ai/api/v1",
    api_key=os.environ["VENICE_API_KEY"],
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=32768,
    temperature=0.7,
)

response = llm.complete("Explain zero data retention in two sentences.")
print(str(response))
```

<Note>
  Defina `context_window` para corresponder ao modelo escolhido — o `OpenAILike` não consegue inferi-lo para IDs de modelos que não sejam da OpenAI. Defina `is_function_calling_model=True` apenas para modelos que suportam [function calling](/guides/features/function-calling).
</Note>

### Mensagens de chat

```python theme={"system"}
from llama_index.core.llms import ChatMessage

messages = [
    ChatMessage(role="system", content="You are a concise, privacy-respecting assistant."),
    ChatMessage(role="user", content="Why does uncensored inference matter for research?"),
]

response = llm.chat(messages)
print(response.message.content)
```

## Streaming

```python theme={"system"}
for chunk in llm.stream_complete("Write a haiku about decentralization."):
    print(chunk.delta, end="", flush=True)
```

## Padrões globais com Settings

Configure os modelos da Venice uma única vez via `Settings` e todos os índices, query engines e agentes irão utilizá-los:

```python theme={"system"}
import os

from llama_index.core import Settings
from llama_index.llms.openai_like import OpenAILike
from llama_index.embeddings.openai_like import OpenAILikeEmbedding

Settings.llm = OpenAILike(
    model="zai-org-glm-5-1",
    api_base="https://api.venice.ai/api/v1",
    api_key=os.environ["VENICE_API_KEY"],
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=32768,
)

Settings.embed_model = OpenAILikeEmbedding(
    model_name="text-embedding-bge-m3",
    api_base="https://api.venice.ai/api/v1",
    api_key=os.environ["VENICE_API_KEY"],
)
```

## Embeddings

```python theme={"system"}
import os

from llama_index.embeddings.openai_like import OpenAILikeEmbedding

embed_model = OpenAILikeEmbedding(
    model_name="text-embedding-bge-m3",
    api_base="https://api.venice.ai/api/v1",
    api_key=os.environ["VENICE_API_KEY"],
)

vector = embed_model.get_text_embedding("Venice AI provides private inference.")
print(f"Embedding dimension: {len(vector)}")
```

## Pipeline RAG

Construa uma query engine com recuperação aumentada sobre seus documentos. Isso utiliza o `Settings.llm` e o `Settings.embed_model` configurados acima:

```python theme={"system"}
from llama_index.core import Document, VectorStoreIndex

documents = [
    Document(text="Venice AI provides private, uncensored AI inference with zero data retention."),
    Document(text="The Venice API is OpenAI-compatible, supporting chat, images, audio, video, and embeddings."),
    Document(text="Venice supports function calling, structured outputs, web search, and reasoning models."),
    Document(text="Privacy tiers include Private (zero retention) and Anonymized (third-party processed)."),
]

index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine(similarity_top_k=2)

response = query_engine.query("What privacy tiers does Venice offer?")
print(str(response))
```

Para carregar seus próprios arquivos a partir de um diretório, use `SimpleDirectoryReader`:

```python theme={"system"}
from llama_index.core import SimpleDirectoryReader, VectorStoreIndex

documents = SimpleDirectoryReader("./data").load_data()
index = VectorStoreIndex.from_documents(documents)
```

## Agentes e ferramentas

Use `FunctionAgent` para dar acesso a ferramentas aos modelos da Venice. Escolha um modelo que suporte [function calling](/guides/features/function-calling):

```python theme={"system"}
import asyncio
import os

from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.openai_like import OpenAILike


def get_venice_model_price(model_id: str) -> str:
    """Get the pricing for a Venice AI model."""
    prices = {
        "venice-uncensored": "Input: $0.20/1M, Output: $0.90/1M",
        "zai-org-glm-5-1": "Input: $1.75/1M, Output: $5.50/1M",
        "qwen3-5-9b": "Input: $0.10/1M, Output: $0.15/1M",
    }
    return prices.get(model_id, f"Model {model_id} not found in price list.")


llm = OpenAILike(
    model="zai-org-glm-5-1",
    api_base="https://api.venice.ai/api/v1",
    api_key=os.environ["VENICE_API_KEY"],
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=32768,
)

agent = FunctionAgent(
    tools=[get_venice_model_price],
    llm=llm,
    system_prompt="You help users find the right Venice AI model. Use tools when needed.",
)


async def main() -> None:
    response = await agent.run("How much does zai-org-glm-5-1 cost?")
    print(str(response))


asyncio.run(main())
```

## Saída estruturada

Envolva o LLM com `as_structured_llm` para validar a resposta final contra um modelo Pydantic:

```python theme={"system"}
import os

from pydantic import BaseModel, Field
from llama_index.core.llms import ChatMessage
from llama_index.llms.openai_like import OpenAILike


class PrivacySummary(BaseModel):
    summary: str = Field(description="One-sentence overview")
    benefits: list[str] = Field(description="Key privacy benefits")
    recommendation: str = Field(description="When to choose this approach")


llm = OpenAILike(
    model="zai-org-glm-5-1",
    api_base="https://api.venice.ai/api/v1",
    api_key=os.environ["VENICE_API_KEY"],
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=32768,
)

structured_llm = llm.as_structured_llm(PrivacySummary)
result = structured_llm.chat([
    ChatMessage(role="user", content="Summarize why private inference beats providers that retain chat logs."),
])

summary = result.raw
print(summary.summary)
print(summary.benefits)
```

Antes de depender de saída estruturada em produção, consulte os modelos que suportam [respostas estruturadas](/guides/features/structured-responses).

## Parâmetros específicos da Venice

Passe opções exclusivas da Venice por meio de `additional_kwargs` usando `extra_body`. Por exemplo, ative a busca na web integrada com `venice_parameters`:

```python theme={"system"}
import os

from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    model="venice-uncensored",
    api_base="https://api.venice.ai/api/v1",
    api_key=os.environ["VENICE_API_KEY"],
    is_chat_model=True,
    context_window=32768,
    additional_kwargs={
        "extra_body": {
            "venice_parameters": {
                "enable_web_search": "auto",
            }
        }
    },
)

response = llm.complete("What are notable AI privacy developments this week?")
print(str(response))
```

Você também pode passar `extra_body` por chamada:

```python theme={"system"}
response = llm.complete(
    "Summarize today's headlines about decentralized AI.",
    extra_body={"venice_parameters": {"enable_web_search": "on"}},
)
```

Consulte a [especificação da API](/api-reference/api-spec) para a lista completa de `venice_parameters` (web scraping, citações, personagens, controles de raciocínio e alternadores de E2EE).

## Modelos recomendados

| Caso de uso                  | Modelo                           | Por quê                                    |
| ---------------------------- | -------------------------------- | ------------------------------------------ |
| Consultas gerais             | `venice-uncensored`              | Rápido, barato, sem censura                |
| Agentes / uso de ferramentas | `zai-org-glm-5-1`                | Modelo flagship privado forte para agentes |
| Raciocínio complexo          | `zai-org-glm-5-1`                | Melhor planejamento em várias etapas       |
| Embeddings (RAG)             | `text-embedding-bge-m3`          | Embeddings privados                        |
| Orçamento / alto volume      | `qwen3-5-9b`                     | Baixo custo por token                      |
| Agentes focados em código    | `qwen3-coder-480b-a35b-instruct` | Otimizado para código                      |

Os IDs dos modelos mudam com o tempo — confirme os IDs atuais com [`GET /models`](/api-reference/endpoint/models/list) ou pela [visão geral dos modelos](/models/overview).

## Vantagem em privacidade

O LlamaIndex é normalmente usado para construir sistemas RAG sobre documentos privados, bases de conhecimento internas e dados de usuários. Combiná-lo com a Venice mantém esse pipeline em inferência privada e sem censura:

* **Zero retenção de dados** nos modelos privados — prompts, trechos recuperados e payloads de ferramentas não são mantidos após a requisição
* **Análise sem censura** quando seus dados ou perguntas acionariam os filtros de outros provedores
* **Encanamento compatível com OpenAI**, para que você possa migrar aplicações LlamaIndex existentes trocando os clientes de LLM e embeddings por `OpenAILike`

## Solução de problemas

<AccordionGroup>
  <Accordion title="401 Não autorizado">
    Confirme que `VENICE_API_KEY` está definida no processo que executa sua aplicação. Reinicie o shell ou o processo após alterar variáveis de ambiente.
  </Accordion>

  <Accordion title="Modelo não encontrado ou erros inesperados de endpoint">
    Use um ID de modelo atual da [página de modelos](/models/overview). Defina `api_base` como `https://api.venice.ai/api/v1` sem caminho ao final — o LlamaIndex adiciona `/chat/completions`.
  </Accordion>

  <Accordion title="Erros de janela de contexto ou de tokens">
    O `OpenAILike` não consegue inferir a janela de contexto para IDs de modelos que não sejam da OpenAI. Defina `context_window` explicitamente para corresponder ao modelo que você está usando.
  </Accordion>

  <Accordion title="As ferramentas são ignoradas">
    Defina `is_function_calling_model=True` e escolha um modelo que suporte [function calling](/guides/features/function-calling). Mantenha as docstrings das ferramentas precisas — o LlamaIndex constrói schemas JSON a partir das assinaturas e da documentação.
  </Accordion>
</AccordionGroup>

<CardGroup cols={2}>
  <Card title="Documentação do LlamaIndex" icon="book" href="https://docs.llamaindex.ai/">
    Índices, query engines, agentes e workflows
  </Card>

  <Card title="Modelos Venice" icon="database" href="/models/overview">
    Navegue pelos modelos e capacidades suportadas
  </Card>
</CardGroup>