AI-Lib
v1.0.1 · Crates.io

Runtime Rust
para AI-Protocol.

Runtime Rust de alto rendimiento para AI-Protocol (v1.0.1). Ruta: manifiesto → Pipeline → HttpTransport. Workspace E/P (ai-lib-core + ai-lib-contact), 13 códigos de error V2 y módulos por feature.

Cargo.toml
ai-lib-rust = "1.0.1"

Características clave

Códigos de error V2 y feature flags

13 códigos de error estándar V2 para un manejo coherente entre proveedores. Módulos por feature: 7 opcionales más un meta-feature full para builds mínimos o completos.

Pipeline basado en operadores

Las respuestas en streaming pasan por operadores componibles: Decoder → Selector → Accumulator → FanOut → EventMapper. Cada etapa se configura por protocolo.

Protocolo + Pipeline

AiClient carga manifiestos y ejecuta el pipeline de operadores (Decoder → Selector → Accumulator → EventMapper). Compatibilidad con rutas V1 y V2.

Workspace E/P

ai-lib-core (ejecución) y ai-lib-contact (política) se publican como crates separados; ai-lib-rust reexporta una fachada estable.

Resilience

Backpressure max_inflight integrado en AiClient. Reintentos, límite de tasa y circuit breaker viven en ai_lib_rust::resilience  opt-in.

Embeddings y vectores

EmbeddingClient with vector operations ?cosine similarity, Euclidean distance, dot product. Construye búsqueda semántica y RAG de forma nativa.

Caché y lotes

Caché de respuestas con TTL (memoria). Ejecución por lotes con concurrencia, timeout y varias estrategias configurables.

Sistema de plugins

Arquitectura de plugins extensible con hooks y cadena de middleware. Añade comportamiento sin modificar el núcleo. Guardrails para filtrado de contenido y detección de PII.

API simple y unificada

El mismo código funciona con los 37+ proveedores. Solo cambia el identificador del modelo ?el manifiesto del protocolo gestiona el resto: endpoint, autenticación, mapeo de parámetros y formato de streaming.

El patrón builder ofrece una API fluida para construir peticiones. Los resultados en stream llegan como StreamingEvent unificados, independientemente del proveedor.

use ai_lib_rust::{AiClient, Message, StreamingEvent};
use futures::StreamExt;

// Works with ANY provider ?protocol-driven
let client = AiClient::new(
    "anthropic/claude-3-5-sonnet"
).await?;

// Builder pattern for chat requests
let mut stream = client.chat()
    .messages(vec![Message::user("Hello")])
    .temperature(0.7)
    .max_tokens(1000)
    .stream()
    .execute_stream()
    .await?;

// Unified streaming events
while let Some(event) = stream.next().await {
    match event? {
        StreamingEvent::PartialContentDelta { content, .. }
            => print!("{content}"),
        StreamingEvent::StreamEnd { stats, .. }
            => println!("\nTokens: {}",
                stats.total_tokens),
        _ => {} // ToolCall, Metadata, etc.
    }
}

Arquitectura interna

Cinco capas desde la API de usuario hasta el transporte HTTP. El pipeline de streaming es el corazón del sistema.

Arquitectura del runtime ai-lib-rust Capa de cliente AiClient · AiClientBuilder · ChatRequestBuilder · ChatResponse Motor de políticas Preflight · Validation · ErrorClassification · Signals Capa de protocolo ProtocolLoader · Manifest · Validator Capa de resiliencia CircuitBreaker · RateLimiter · Retry Pipeline de streaming Decoder Selector Accumulator FanOut EventMapper Capa de transporte HttpTransport (reqwest) · Auth · Middleware OpenAI · Anthropic · Gemini · DeepSeek · Qwen · 37 Proveedores

Resumen de módulos

client/ + error_code/

AiClient, AiClientBuilder, ChatRequestBuilder, lógica de ejecución, motor de políticas, comprobaciones previas, clasificación de errores, CallStats, CancelHandle.

protocol/

ProtocolLoader (local/URL/GitHub), validador JSON Schema, estructura ProtocolManifest, compilación de UnifiedRequest y tipos de configuración.

pipeline/

Decoder (SSE, JSON Lines), Selector (JSONPath), Accumulator (llamadas a herramientas), FanOut, EventMapper y operadores Retry / Fallback.

transport/

HttpTransport (reqwest), resolución de API key (keyring + variables de entorno), proxy/timeout y middleware.

resilience/

Circuit breaker (open/half-open/closed), limitador token bucket y backpressure max-inflight.

embeddings/

EmbeddingClient, EmbeddingClientBuilder y operaciones vectoriales (similitud coseno, distancia euclídea, producto punto).

cache/ + batch/

CacheManager con TTL (MemoryCache, NullCache). BatchCollector y BatchExecutor con control de concurrencia y varias estrategias.

plugins/ + guardrails/ + structured/

Plugin trait, PluginRegistry, HookManager y cadena de middleware. Guardrails con filtros por palabra/patrón y detección de PII.

Empieza a construir con Rust