TensorZero

TensorZero é uma stack open-source para aplicações LLM de nível industrial:

• Gateway
  • Acesse todos os principais provedores de LLM (API ou auto-hospedados) através de uma única API unificada
  • Inferência com streaming, uso de ferramentas, geração estruturada (modo JSON), batch, multimodal (VLMs), inputs de arquivos, cache, etc.
  • Defina templates de prompt e esquemas para impor uma interface consistente e tipada entre sua aplicação e os LLMs
  • Atenda necessidades extremas de throughput e latência, graças ao Rust: overhead de latência p99 <1ms em 10k+ QPS
  • Integre usando nosso cliente Python, qualquer SDK OpenAI ou cliente compatível com OpenAI, ou nossa API HTTP (use qualquer linguagem de programação)
  • Garanta alta disponibilidade com roteamento, retentativas, fallbacks, balanceamento de carga, timeouts granulares, etc.
  • Em breve: embeddings; voz em tempo real
• Observabilidade
  • Armazene inferências e feedback (métricas, edições humanas, etc.) em seu próprio banco de dados
  • Analise inferências individuais ou padrões agregados de alto nível usando a UI do TensorZero ou programaticamente
  • Construa datasets para otimização, avaliações e outros fluxos de trabalho
  • Reexecute inferências históricas com novos prompts, modelos, estratégias de inferência, etc.
  • Exporte traces OpenTelemetry (OTLP) para sua ferramenta de observabilidade preferida
  • Em breve: depuração assistida por IA e análise de causa raiz; rotulagem de dados assistida por IA
• Otimização
  • Otimize seus modelos com fine-tuning supervisionado, RLHF e outras técnicas
  • Otimize seus prompts com algoritmos automatizados de engenharia de prompts como MIPROv2
  • Otimize sua estratégia de inferência com aprendizado em contexto dinâmico, chain of thought, best/mixture-of-N sampling, etc.
  • Habilite um ciclo de feedback para seus LLMs: um flywheel de dados & aprendizado transformando dados de produção em modelos mais inteligentes, rápidos e baratos
  • Em breve: otimização programática; geração de dados sintéticos
• Avaliações
  • Avalie inferências individuais com avaliações estáticas baseadas em heurísticas ou juízes LLM (≈ testes unitários para LLMs)
  • Avalie fluxos de trabalho end-to-end com avaliações dinâmicas com total flexibilidade (≈ testes de integração para LLMs)
  • Otimize juízes LLM como qualquer outra função do TensorZero para alinhá-los às preferências humanas
  • Em breve: mais avaliadores integrados; avaliações headless
• Experimentação
  • Implemente com confiança usando testes A/B integrados para modelos, prompts, provedores, hiperparâmetros, etc.
  • Force experimentos fundamentados (RCTs) em fluxos de trabalho complexos, incluindo sistemas LLM multi-turn e compostos
  • Em breve: bandidos multi-armados; experimentos gerenciados por IA
• & mais!
  • Construa aplicações simples ou implantações massivas com orquestração amigável ao GitOps
  • Estenda o TensorZero com escapes integrados, uso prioritariamente programático, acesso direto ao banco de dados e mais
  • Integre com ferramentas de terceiros: observabilidade e avaliações especializadas, provedores de modelos, frameworks de orquestração de agentes, etc.
  • Em breve: playground UI

Use o que precisar, adote incrementalmente e complemente com outras ferramentas.

Website · Documentação · Twitter · Slack · Discord

Início Rápido (5min) · Guia de Implantação · Referência da API · Referência de Configuração

Funcionalidades

🌐 Gateway LLM

Integre com o TensorZero uma vez e acesse todos os principais provedores de LLM.

from tensorzero import TensorZeroGateway  # or AsyncTensorZeroGateway


with TensorZeroGateway.build_embedded(clickhouse_url="...", config_file="...") as client:
    response = client.inference(
        model_name="openai::gpt-4o-mini",
        # Try other providers easily: "anthropic::claude-3-7-sonnet-20250219"
        input={
            "messages": [
                {
                    "role": "user",
                    "content": "Write a haiku about artificial intelligence.",
                }
            ]
        },
    )

from openai import OpenAI  # or AsyncOpenAI
from tensorzero import patch_openai_client

client = OpenAI()

patch_openai_client(
    client,
    clickhouse_url="http://chuser:chpassword@localhost:8123/tensorzero",
    config_file="config/tensorzero.toml",
    async_setup=False,
)

response = client.chat.completions.create(
    model="tensorzero::model_name::openai::gpt-4o-mini",
    # Try other providers easily: "tensorzero::model_name::anthropic::claude-3-7-sonnet-20250219"
    messages=[
        {
            "role": "user",
            "content": "Write a haiku about artificial intelligence.",
        }
    ],
)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "http://localhost:3000/openai/v1",
});

const response = await client.chat.completions.create({
  model: "tensorzero::model_name::openai::gpt-4o-mini",
  // Try other providers easily: "tensorzero::model_name::anthropic::claude-3-7-sonnet-20250219"
  messages: [
    {
      role: "user",
      content: "Write a haiku about artificial intelligence.",
    },
  ],
});

curl -X POST "http://localhost:3000/inference" \
  -H "Content-Type: application/json" \
  -d '{
    "model_name": "openai::gpt-4o-mini",
    "input": {
      "messages": [
        {
          "role": "user",
          "content": "Write a haiku about artificial intelligence."
        }
      ]
    }
  }'

📈 Otimização LLM

Envie métricas de produção e feedback humano para otimizar facilmente seus prompts, modelos e estratégias de inferência — usando a UI ou programaticamente.

Otimização de Modelo

Otimize modelos closed-source e open-source usando fine-tuning supervisionado (SFT) e fine-tuning por preferência (DPO).

Fine-tuning Supervisionado — UI	Fine-tuning por Preferência (DPO) — Jupyter Notebook

Otimização em Tempo de Inferência

Aumente performance atualizando dinamicamente seus prompts com exemplos relevantes, combinando respostas de múltiplas inferências e mais.

Best-of-N Sampling	Mixture-of-N Sampling
Dynamic In-Context Learning (DICL)	Chain-of-Thought (CoT)

Em breve mais...

Otimização de Prompt

Otimize seus prompts programaticamente usando técnicas de otimização baseadas em pesquisa.

MIPROv2	Integração com DSPy
	O TensorZero vem com várias receitas de otimização prontas, mas você também pode facilmente criar as suas próprias. Este exemplo mostra como otimizar uma função do TensorZero usando uma ferramenta arbitrária — neste caso, o DSPy, uma biblioteca popular para engenharia de prompts automatizada.

Em breve mais novidades...

🔍 Observabilidade de LLM

Aproxime-se para depurar chamadas individuais de API, ou afaste-se para monitorar métricas entre modelos e prompts ao longo do tempo — tudo usando a interface de usuário open-source do TensorZero.

Observabilidade » Inferência	Observabilidade » Função

📊 Avaliações de LLM

Compare prompts, modelos e estratégias de inferência usando as Avaliações do TensorZero — com suporte para heurísticas e juízes baseados em LLM.

Avaliação » Interface	Avaliação » CLI
	docker compose run --rm evaluations \ --evaluation-name extract_data \ --dataset-name hard_test_cases \ --variant-name gpt_4o \ --concurrency 5 Run ID: 01961de9-c8a4-7c60-ab8d-15491a9708e4 Number of datapoints: 100 ██████████████████████████████████████ 100/100 exact_match: 0.83 ± 0.03 semantic_match: 0.98 ± 0.01 item_count: 7.15 ± 0.39

Demonstração

Veja os LLMs melhorando em extração de dados em tempo real com o TensorZero!

Aprendizado dinâmico em contexto (DICL) é uma poderosa otimização em tempo de inferência disponível pronta para uso no TensorZero. Ele melhora o desempenho do LLM incorporando automaticamente exemplos históricos relevantes no prompt, sem a necessidade de ajuste fino do modelo.

https://github.com/user-attachments/assets/4df1022e-886e-48c2-8f79-6af3cdad79cb

Comece Agora

Comece a construir hoje. O Guia Rápido mostra como é fácil configurar uma aplicação com LLM usando o TensorZero.

Dúvidas? Pergunte-nos no Slack ou Discord.

Usando o TensorZero no trabalho? Envie-nos um e-mail para [email protected] para configurar um canal no Slack ou Teams com sua equipe (gratuito).

Trabalhe conosco. Estamos contratando em NYC. Também adoraríamos receber contribuições open-source!

Exemplos

Estamos trabalhando em uma série de exemplos completos e executáveis que ilustram o ciclo de dados e aprendizado do TensorZero.

Otimizando Extração de Dados (NER) com TensorZero

Este exemplo mostra como usar o TensorZero para otimizar um pipeline de extração de dados. Demonstramos técnicas como fine-tuning e aprendizado dinâmico em contexto (DICL). No final, um modelo otimizado GPT-4o Mini supera o GPT-4o nesta tarefa — com uma fração do custo e latência — usando uma pequena quantidade de dados de treinamento.

RAG Agente — Resposta a Perguntas Multi-Hop com LLMs

Este exemplo mostra como construir um agente de recuperação multi-hop usando o TensorZero. O agente pesquisa iterativamente a Wikipedia para coletar informações e decide quando tem contexto suficiente para responder a uma pergunta complexa.

Escrevendo Haikus para Satisfazer um Juiz com Preferências Ocultas

Este exemplo faz fine-tuning do GPT-4o Mini para gerar haikus adaptados a um gosto específico. Você verá o "ciclo de dados em uma caixa" do TensorZero em ação: variantes melhores levam a dados melhores, e dados melhores levam a variantes melhores. Você verá o progresso ao ajustar o LLM várias vezes.

Melhorando a Habilidade de Xadrez do LLM com Amostragem Best-of-N

Este exemplo mostra como a amostragem best-of-N pode melhorar significativamente as habilidades de xadrez de um LLM, selecionando os movimentos mais promissores entre várias opções geradas.

Melhorando Raciocínio Matemático com uma Receita Personalizada para Engenharia de Prompts Automatizada (DSPy)

O TensorZero fornece várias receitas de otimização pré-construídas para fluxos de trabalho comuns de engenharia de LLM. Mas você também pode facilmente criar suas próprias receitas e fluxos de trabalho! Este exemplo mostra como otimizar uma função do TensorZero usando uma ferramenta arbitrária — neste caso, o DSPy.

E muitos outros a caminho!