AI-Lib AI-Lib
v0.7.1 · Crates.io

Runtime Rust
para AI-Protocol

Cliente AI de alto rendimiento e impulsado por protocolo. Códigos de error V2 estándar (13 códigos), feature flags (7 características + meta-característica completa), cero lógica de proveedor hardcodeada, pipeline de streaming basado en operadores, seguridad de tipos en tiempo de compilación y sobrecarga submilisegundo.

Cargo.toml
ai-lib = "0.7.1"

Características principales

Códigos de error V2 y feature flags

13 códigos de error estándar V2 para manejo consistente de errores entre proveedores. Módulos con feature-gate: 7 características opcionales más meta-característica completa para builds mínimos o completos.

Pipeline basado en operadores

Las respuestas en streaming fluyen por operadores composables: Decoder → Selector → Accumulator → FanOut → EventMapper. Cada etapa está configurada por protocolo.

Carga de protocolo

Carga manifiestos de proveedores desde archivos locales, variables de entorno o fallback de GitHub. Soporta hot-reload mediante vigilancia de archivos. Sin reinicio necesario para actualizaciones de configuración.

Patrones de resiliencia

Circuit breaker integrado, limitador de tasa token bucket, reintento con backoff exponencial y backpressure max-inflight. Todo configurable mediante variables de entorno.

Embeddings y vectores

EmbeddingClient con operaciones vectoriales: similitud coseno, distancia euclidiana, producto escalar. Construye búsqueda semántica y aplicaciones RAG nativamente.

Caché y batch

Caché de respuestas con TTL (backend en memoria). Ejecución batch con concurrencia, timeout y múltiples estrategias de procesamiento configurables.

Sistema de plugins

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

API simple y unificada

El mismo código funciona con los 35+ proveedores. Solo cambia el identificador del modelo — el manifiesto de protocolo maneja todo lo demás: endpoint, autenticación, mapeo de parámetros, formato de streaming.

El patrón builder proporciona una API fluida para la construcción de peticiones. Los resultados en streaming llegan como tipos unificados StreamingEvent independientemente del proveedor subyacente.

use ai_lib::{AiClient, Message, StreamingEvent};

// 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()
    .user("Explain AI-Protocol")
    .temperature(0.7)
    .max_tokens(1000)
    .stream()
    .execute_stream()
    .await?;

// Unified streaming events
while let Some(event) = stream.next().await {
    match event? {
        StreamingEvent::ContentDelta { text, .. }
            => print!("{text}"),
        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.

ai-lib-rust Runtime Architecture Client Layer AiClient · AiClientBuilder · ChatRequestBuilder · ChatResponse Policy Engine Preflight · Validation · ErrorClassification · Signals Protocol Layer ProtocolLoader · Manifest · Validator Resilience Layer CircuitBreaker · RateLimiter · Retry Streaming Pipeline Decoder Selector Accumulator FanOut EventMapper Transport Layer HttpTransport (reqwest) · Auth · Middleware OpenAI · Anthropic · Gemini · DeepSeek · Qwen · 35+ Providers

Resumen de módulos

client/ + error_code/

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

protocol/

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

pipeline/

Decoder (SSE, JSON Lines), Selector (JSONPath), Accumulator (tool calls), FanOut (multi-candidato), EventMapper (eventos unificados), operadores Retry y Fallback.

transport/

HttpTransport (reqwest), resolución de API key (keyring + env vars), configuración proxy/timeout, soporte de middleware.

resilience/

Circuit breaker (open/half-open/closed), limitador de tasa token bucket, backpressure semáforo max-inflight.

embeddings/

EmbeddingClient, EmbeddingClientBuilder, operaciones vectoriales (similitud coseno, distancia euclidiana, producto escalar).

cache/ + batch/

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

plugins/ + guardrails/ + structured/

Plugin trait, PluginRegistry, HookManager, cadena de middleware. Guardrails con filtros keyword/pattern y detección de PII.

Empieza a construir con Rust