TensorZero

TensorZero est une pile open-source pour des applications LLM de qualité industrielle :

• Passerelle (Gateway)
  • Accéder à tous les principaux fournisseurs de LLM (API ou auto-hébergés) via une API unifiée
  • Inférence avec streaming, utilisation d'outils, génération structurée (mode JSON), traitement par lots, multimodalité (VLMs), entrées de fichiers, cache, etc.
  • Définir des modèles de prompts et des schémas pour imposer une interface cohérente et typée entre votre application et les LLMs
  • Répondre à des besoins extrêmes de débit et de latence, grâce à Rust : surcharge de latence p99 <1ms à 10k+ QPS
  • Intégration via notre client Python, n'importe quel SDK OpenAI ou client compatible OpenAI, ou notre API HTTP (utilisable avec n'importe quel langage de programmation)
  • Assurer une haute disponibilité avec routage, nouvelles tentatives, solutions de repli, équilibrage de charge, délais d'attente granulaires, etc.
  • Bientôt : embeddings ; voix en temps réel
• Observabilité
  • Stocker les inférences et feedbacks (métriques, modifications humaines, etc.) dans votre propre base de données
  • Explorer des inférences individuelles ou des tendances agrégées via l'interface TensorZero ou programmatiquement
  • Construire des jeux de données pour l'optimisation, les évaluations et autres workflows
  • Rejouer des inférences historiques avec de nouveaux prompts, modèles, stratégies d'inférence, etc.
  • Exporter des traces OpenTelemetry (OTLP) vers votre outil d'observabilité préféré
  • Bientôt : débogage assisté par IA ; étiquetage de données assisté par IA
• Optimisation
  • Optimiser vos modèles par fine-tuning supervisé, RLHF et autres techniques
  • Optimiser vos prompts avec des algorithmes automatisés comme MIPROv2
  • Optimiser votre stratégie d'inférence avec apprentissage contextuel dynamique, chain of thought, échantillonnage best/mixture-of-N, etc.
  • Activer une boucle de feedback pour vos LLMs : une roue d'apprentissage transformant les données de production en modèles plus intelligents, rapides et économiques
  • Bientôt : optimisation programmatique ; génération de données synthétiques
• Évaluations
  • Évaluer des inférences individuelles avec des évaluations statiques basées sur des heuristiques ou juges LLM (≈ tests unitaires pour LLMs)
  • Évaluer des workflows complets avec des évaluations dynamiques offrant une flexibilité totale (≈ tests d'intégration pour LLMs)
  • Optimiser les juges LLM comme toute autre fonction TensorZero pour les aligner sur les préférences humaines
  • Bientôt : plus d'évaluateurs intégrés ; évaluations headless
• Expérimentation
  • Déployer en confiance avec des tests A/B intégrés pour modèles, prompts, fournisseurs, hyperparamètres, etc.
  • Appliquer des expérimentations rigoureuses (RCTs) dans des workflows complexes, y compris systèmes LLM multi-tours et composés
  • Bientôt : bandits multi-bras ; expérimentations gérées par IA
• & plus !
  • Construire des applications simples ou des déploiements massifs avec une orchestration compatible GitOps
  • Étendre TensorZero avec des échappatoires intégrées, une utilisation programmatique prioritaire, un accès direct aux bases de données, etc.
  • Intégrer des outils tiers : observabilité spécialisée, évaluations, fournisseurs de modèles, frameworks d'orchestration d'agents, etc.
  • Bientôt : aire de jeu UI

Prenez ce dont vous avez besoin, adoptez progressivement et complétez avec d'autres outils.

Site Web · Documentation · Twitter · Slack · Discord

Démarrage rapide (5min) · Guide de déploiement · Référence API · Référence de configuration

Fonctionnalités

🌐 Passerelle LLM

Intégrez TensorZero une fois et accédez à tous les principaux fournisseurs 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."
        }
      ]
    }
  }'

📈 Optimisation LLM

Envoyez des métriques de production et des feedbacks humains pour optimiser facilement vos prompts, modèles et stratégies d'inférence — via l'interface ou programmatiquement.

Optimisation de modèles

Optimisez des modèles open-source et propriétaires via fine-tuning supervisé (SFT) et fine-tuning par préférences (DPO).

Fine-tuning supervisé — UI	Fine-tuning par préférences (DPO) — Jupyter Notebook

Optimisation temps réel

Améliorez les performances en mettant à jour dynamiquement vos prompts avec des exemples pertinents, combinant des réponses de multiples inférences, etc.

Échantillonnage Best-of-N	Échantillonnage Mixture-of-N
Apprentissage contextuel dynamique (DICL)	Chaîne de pensée (CoT)

Plus à venir...

Optimisation de prompts

Optimisez vos prompts programmatiquement avec des techniques de recherche avancées.

MIPROv2	Intégration DSPy
	TensorZero propose plusieurs recettes d'optimisation prédéfinies, mais vous pouvez aussi facilement créer les vôtres. Cet exemple montre comment optimiser une fonction TensorZero à l'aide d'un outil arbitraire — ici, DSPy, une bibliothèque populaire pour l'ingénierie automatique de prompts.

Plus à venir bientôt...

🔍 Observabilité des LLM

Zoomez pour déboguer des appels API individuels, ou dézoomez pour surveiller des métriques sur les modèles et prompts au fil du temps — le tout via l'interface open-source de TensorZero.

Observabilité » Inférence	Observabilité » Fonction

📊 Évaluations des LLM

Comparez des prompts, modèles et stratégies d'inférence avec les Évaluations TensorZero — avec support pour heuristiques et juges LLM.

Évaluation » UI	Évaluation » 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

Démo

Observez les LLM s'améliorer en extraction de données en temps réel avec TensorZero !

L'apprentissage dynamique en contexte (DICL) est une puissante optimisation d'inférence disponible nativement dans TensorZero. Elle améliore les performances des LLM en incorporant automatiquement des exemples historiques pertinents dans le prompt, sans nécessiter de fine-tuning du modèle.

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

Premiers Pas

Commencez à développer dès aujourd'hui. Le Guide de démarrage rapide montre qu'il est facile de configurer une application LLM avec TensorZero.

Des questions ? Contactez-nous sur Slack ou Discord.

Utilisez TensorZero au travail ? Envoyez-nous un email à [email protected] pour configurer un canal Slack ou Teams avec votre équipe (gratuit).

Travailler avec nous. Nous recrutons à New York. Nous accueillons aussi les contributions open-source !

Exemples

Nous préparons une série d'exemples complets exécutables illustrant la boucle de rétroaction données & apprentissage de TensorZero.

Optimisation d'extraction de données (NER) avec TensorZero

Cet exemple montre comment utiliser TensorZero pour optimiser un pipeline d'extraction de données. Nous démontrons des techniques comme le fine-tuning et l'apprentissage dynamique en contexte (DICL). Au final, un modèle optimisé GPT-4o Mini surpasse GPT-4o sur cette tâche — pour une fraction du coût et de la latence — en utilisant peu de données d'entraînement.

RAG agentique — Questions-réponses multi-sauts avec LLMs

Cet exemple montre comment construire un agent de recherche multi-sauts avec TensorZero. L'agent parcourt itérativement Wikipédia pour collecter des informations, et décide quand il a assez de contexte pour répondre à une question complexe.

Écrire des haïkus satisfaisant un juge aux préférences cachées

Cet exemple effectue un fine-tuning de GPT-4o Mini pour générer des haïkus adaptés à un goût spécifique. Vous verrez la "boucle de rétroaction données en boîte" de TensorZero en action : de meilleures variantes produisent de meilleures données, qui produisent à leur tour de meilleures variantes. Vous observerez les progrès en fine-tunant le LLM à plusieurs reprises.

Améliorer les capacités d'échecs d'un LLM avec l'échantillonnage Best-of-N

Cet exemple montre comment l'échantillonnage Best-of-N peut significativement améliorer les capacités d'un LLM aux échecs en sélectionnant les coups les plus prometteurs parmi plusieurs options générées.

Améliorer le raisonnement mathématique avec une recette personnalisée pour l'ingénierie automatique de prompts (DSPy)

TensorZero fournit plusieurs recettes d'optimisation prédéfinies couvrant des workflows courants d'ingénierie LLM. Mais vous pouvez aussi facilement créer vos propres recettes et workflows ! Cet exemple montre comment optimiser une fonction TensorZero avec un outil arbitraire — ici, DSPy.

Et bien d'autres à venir !