El cliente oficial de Python y servidor de Model Context Protocol (MCP) para BanditDB — la base de datos de Bandidos Contextuales ultrarrápida y sin bloqueos escrita en Rust.
BanditDB abstrae el complejo álgebra lineal del Aprendizaje por Refuerzo (LinUCB, Muestreo de Thompson) detrás de una API extremadamente simple. Crea personalizadores en tiempo real, pruebas A/B dinámicas y proporciona a los agentes LLM una memoria persistente matemáticamente rigurosa.
pip install banditdb-pythonRequiere que el servidor Rust de BanditDB esté en ejecución (por defecto: http://localhost:8080).
Related MCP server: Copilot Memory Store
El cliente incluye agrupación automática de conexiones, reintentos con retroceso exponencial y tiempos de espera estrictos.
from banditdb import Client, BanditDBError
# Connect to the BanditDB server.
# Pass api_key if BANDITDB_API_KEY is set on the server.
db = Client(
url="http://localhost:8080",
timeout=2.0,
api_key="your-secret-key", # omit if server runs without auth
)
try:
# 1. Create a campaign (run once at startup)
# algorithm defaults to "linucb"; use "thompson_sampling" for Bayesian exploration
db.create_campaign(
campaign_id="checkout_upsell",
arms=["offer_discount", "offer_free_shipping"],
feature_dim=3,
)
# or: db.create_campaign(..., algorithm="thompson_sampling")
# 2. A user arrives — ask the database what to show them
# Context: [is_mobile, cart_value_normalized, is_returning_user]
arm_id, interaction_id = db.predict("checkout_upsell", [1.0, 0.8, 0.0])
print(f"Showing: {arm_id}") # e.g., "offer_free_shipping"
# 3. The user clicked — send the reward
db.reward(interaction_id, reward=1.0)
except BanditDBError as e:
print(f"Database error: {e}")Salud
Método | Descripción |
| Devuelve |
| Devuelve el diccionario de salud completo, incluidos la |
Campañas
Método | Descripción |
| Registrar una nueva campaña. |
| Devuelve una lista de todas las campañas (activas y archivadas) con |
| Devuelve el estado completo por brazo: |
| Informe de convergencia a nivel de negocio. |
| Diagnósticos de operador: normas theta por brazo, límites de incertidumbre A_inv, salud de entropía ( |
| Eliminación suave: pausa predicciones/recompensas pero conserva todos los pesos aprendidos. Recuperable con |
| Restaurar una campaña archivada a estado activo con todos los pesos intactos. |
| Eliminar una campaña de forma permanente. Devuelve |
Predicción y Recompensa
Método | Descripción |
| Devuelve |
| Predice hasta 100 pares campaña/contexto en una sola ida y vuelta. Cada elemento: |
| Registrar el resultado. |
Datos y Exportación
Método | Descripción |
| Vaciar WAL, crear instantáneas de los modelos, escribir fragmentos Parquet, ejecutar reentrenamiento neuronal + evaluación de torneo, rotar WAL. Devuelve una cadena de resumen. |
| Listar los fragmentos de exportación Parquet agrupados por campaña. Devuelve |
Los agentes LLM estándar no tienen estado — si enrutan una tarea al modelo equivocado y fallan, repiten el mismo error al día siguiente. El servidor MCP integrado de BanditDB proporciona a todo el enjambre de agentes una memoria persistente compartida.
# Set environment variables before starting
export BANDITDB_URL=http://localhost:8080
export BANDITDB_API_KEY=your-secret-key # omit if server runs without auth
banditdb-mcpAñade a tu archivo de configuración de Claude:
Mac: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
{
"mcpServers": {
"banditdb": {
"command": "banditdb-mcp",
"args": [],
"env": {
"BANDITDB_URL": "http://localhost:8080",
"BANDITDB_API_KEY": "your-secret-key"
}
}
}
}El enjambre de agentes ahora tiene nueve herramientas:
Herramienta | Qué hace |
| Crear una nueva campaña de decisión. Acepta |
| Listar todas las campañas activas (muestra |
| Inspeccionar el estado de aprendizaje por brazo: |
| Informe de convergencia a nivel de negocio. Indica si la campaña ha convergido estadísticamente y qué brazo está ganando con intervalos de confianza. |
| Preguntar a BanditDB qué brazo elegir para un contexto dado. Devuelve el brazo y un |
| Obtener decisiones para múltiples campañas en una sola ida y vuelta. Pasa una lista de diccionarios |
| Informar si la acción elegida tuvo éxito (1.0) o falló (0.0). Actualiza el modelo compartido. |
| Eliminación suave de una campaña. Pausa predicciones/recompensas pero conserva todos los pesos aprendidos. |
| Restaurar una campaña archivada a estado activo con todos los pesos intactos. |
Cada decisión tomada por cualquier agente de la red mejora el enrutamiento para todos los agentes futuros.
BanditDB registra cada predicción y recompensa como eventos en un registro de escritura anticipada (WAL). Llamar a checkpoint() compila los pares predicción→recompensa completados en archivos Parquet comprimidos con Snappy — uno por campaña — para análisis offline con Polars o Pandas.
Se garantiza que cada predicción aparezca en el archivo Parquet incluso si su recompensa llega horas después: BanditDB reemite las interacciones en vuelo en cada checkpoint, de modo que las recompensas retrasadas siempre se capturan en un ciclo futuro.
# Checkpoint: snapshot models, write Parquet, rotate the WAL.
# Call this on a schedule or after significant traffic.
summary = db.checkpoint()
print(summary)
# "Checkpoint written and WAL rotated: 2 campaigns, offset 4821 bytes,
# 150 interactions exported, 3 in-flight re-emitted"
# List which Parquet files are available
print(db.export())
# 'Parquet files in /data/exports: ["llm_routing.parquet"]'
# Load directly from the mounted volume into Polars.
# Flat schema: interaction_id | arm_id | reward | predicted_at | rewarded_at | propensity | feature_0 | ...
import polars as pl
df = pl.read_parquet("/data/exports/llm_routing.parquet")
print(df.head())
print(df.columns)El SDK incluye tres estimadores OPE en banditdb.eval. Responden a la pregunta: "¿cuál habría sido mi recompensa promedio bajo una política diferente — sin ejecutar un experimento en vivo?"
Instala las dependencias de evaluación:
pip install "banditdb-python[eval]"Estimador | Función | Cómo funciona | Cuándo usarlo |
Replay |
| Acepta cada interacción con probabilidad | Comprobación de referencia. Se espera baja cobertura — se usa ~1/K de las interacciones. |
IPS / SNIPS |
| Usa cada interacción con peso de importancia | Estimador principal. Úsalo cuando tengas suficientes datos pero quieras cobertura completa. |
Doblemente Robusto |
| Ajusta un modelo de recompensa lineal y luego aplica una corrección IPS sobre los residuos. Consistente si el modelo de recompensa o las propensiones son correctos. | Mejor eficiencia estadística. Úsalo al comparar múltiples políticas o al barrer |
Los tres estimadores:
Acepta un DataFrame de Polars o pandas cargado desde una exportación Parquet de BanditDB
Evalúa la política aleatoria uniforme como objetivo (la línea base insesgada a superar)
Lanza un ValueError para campañas de Thompson Sampling (la columna propensity es null — TS no registra propensiones)
Devuelve un OPEResult con estimate, std_error, n_used, n_total y method
import polars as pl
from banditdb.eval import replay, ips, doubly_robust
df = pl.read_parquet("/data/exports/llm_routing.parquet")
# How much reward would a uniform random policy have earned?
print(replay(df))
# OPEResult(method='replay', estimate=0.4821, std_error=0.0312, coverage=22.1% [33/149])
print(ips(df))
# OPEResult(method='ips', estimate=0.5103, std_error=0.0187, coverage=100.0% [149/149])
print(doubly_robust(df))
# OPEResult(method='doubly_robust', estimate=0.5219, std_error=0.0141, coverage=100.0% [149/149])
# Compare against the observed reward of the logging policy:
print("Observed (logging policy):", df["reward"].mean())
# If observed >> estimate, the campaign has learned something real — it outperforms random.Uso práctico: haz un barrido de alpha offline antes de desplegar. Entrena una campaña con tráfico real, guarda un checkpoint en Parquet y luego reproduce diferentes valores de alpha mediante doubly_robust() para encontrar el mejor nivel de exploración — no se necesita ningún experimento en vivo.
Nota: OPE requiere la columna
propensity, que solo se registra para las campañas de LinUCB. Las campañas de Thompson Sampling registran propensionesnullporque la selección de brazos de TS es estocástica y el cálculo de propensiones requiere una política de registro determinista.
BanditDB admite cuatro algoritmos, seleccionados al crear la campaña.
Algoritmo | Valor de | Estilo de exploración | Cuándo usarlo |
LinUCB |
| Bonus UCB determinista: | Predecible y ajustable. Haz un barrido de |
Linear Thompson Sampling |
| Muestrea θ̃ ~ N(θ, α²·A⁻¹) y puntúa mediante θ̃·x | Posterior bayesiano — no se necesita barrido de alpha. Los usuarios concurrentes diversifican automáticamente las elecciones. |
NeuralLinUCB |
| Embedding profundo de MLP + LinUCB en el espacio de embeddings | Funciones de recompensa no lineales. Reentrena el MLP cada N recompensas. |
Progressive |
| Torneo de autoajuste: ejecuta base + retador en paralelo y desvía el tráfico al ganador | Selección de modelo sin configuración. Elige automáticamente el mejor algoritmo. |
from banditdb import Client, NeuralLinUCBConfig, ProgressiveConfig
db = Client("http://localhost:8080")
# LinUCB (default)
db.create_campaign("routing", ["fast", "cheap"], feature_dim=4, alpha=1.5)
# Thompson Sampling — natural Bayesian exploration, alpha=1.0 is ideal
db.create_campaign("routing_ts", ["fast", "cheap"], feature_dim=4,
algorithm="thompson_sampling")
# NeuralLinUCB — learns a deep embedding of the context, then applies LinUCB
cfg = NeuralLinUCBConfig(
context_dim=4, # must match feature_dim
embed_dim=32, # arm matrix dimension (default 32)
hidden_dim=128, # MLP hidden layer width (default 128)
retrain_every=200, # retrain the MLP every N cumulative rewards
)
db.create_campaign("routing_neural", ["fast", "cheap"], feature_dim=4, algorithm=cfg)
# Progressive — runs LinUCB vs NeuralLinUCB, shifts traffic to whoever wins SNIPS checkpoints
cfg = ProgressiveConfig(
base="linucb",
challenger=NeuralLinUCBConfig(context_dim=4, embed_dim=32),
min_obs=100, # minimum buffer entries per arm before any traffic shift
required_wins=3, # consecutive checkpoint wins to earn one traffic step
step_bps=1000, # traffic delta per win run, in basis points (1000 = 10%)
)
db.create_campaign("routing_prog", ["fast", "cheap"], feature_dim=4, algorithm=cfg)Los cuatro algoritmos comparten el mismo bucle predict → reward.
Excepción | Cuándo se lanza |
| Excepción base — captúrala para gestionar todos los errores del SDK. |
| El servidor está sin conexión o es inalcanzable. |
| La solicitud superó el tiempo de espera configurado. |
| El servidor devolvió un error (p. ej., campaña no encontrada, no autorizado). |
Apache-2.0 — Copyright (C) 2026 Simeon Lukov y Dynamic Pricing Ltd. Consulta el repositorio principal para más detalles.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
No tool schema history has been recorded yet.
This server cannot be installed
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Universal memory for AI agents and tools. Save, organize and search context anywhere.
Persistent memory and knowledge management for AI agents with semantic search and 50+ tools.
Shared, governed long-term memory for AI agents across tools and sessions via MCP and REST.
Persistent, inspectable memory for AI agents with lineage, correction, and a hosted MCP endpoint.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/dynamicpricing-ai/banditdb-python'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
