open-index/open-npm huggingface dataset:
npm package: @llm-dev-ops/llm-auto-optimizer-cli-linux-x64
Description: LLM Auto Optimizer CLI for linux-x64
Author: LLM Auto Optimizer Contributors
Latest version: 0.1.2

# @llm-dev-ops/llm-auto-optimizer-cli-linux-x64

This package contains the precompiled binary for LLM Auto Optimizer CLI on linux-x64.

You should not install this package directly. Install `@llm-dev-ops/optimizer` instead.

```bash
npm install -g @llm-dev-ops/optimizer
```

## License

Apache-2.0
npm package: @llm-dev-ops/llm-config-api
Description: HTTP API server for configuration management (Rust crate - use via cargo or build from source)
Author: LLM DevOps Team
Latest version: 0.5.0

# llm-config-api

[![Crates.io](https://img.shields.io/crates/v/llm-config-api.svg)](https://crates.io/crates/llm-config-api)
[![Documentation](https://docs.rs/llm-config-api/badge.svg)](https://docs.rs/llm-config-api)
[![License](https://img.shields.io/crates/l/llm-config-api.svg)](https://github.com/globalbusinessadvisors/llm-config-manager/blob/main/LICENSE)

REST API server for LLM Config Manager with JWT authentication, RBAC, rate limiting, and comprehensive security features.

## Features

- **REST API**: Full-featured REST API for configuration management
- **JWT Authentication**: Secure token-based authentication
- **RBAC Integration**: Role-based access control for all endpoints
- **Rate Limiting**: Per-client rate limiting with token bucket
- **CORS Support**: Configurable CORS policies
- **OpenAPI Documentation**: Auto-generated API documentation
- **Health Checks**: Liveness and readiness probes
- **Metrics Export**: Prometheus metrics endpoint

## Usage

```toml
[dependencies]
llm-config-api = "0.5.0"
tokio = { version = "1", features = ["full"] }
```

```rust
use llm_config_api::ApiServer;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let server = ApiServer::builder()
        .bind("0.0.0.0:8080")
        .with_jwt_secret("your-secret-key")
        .build()
        .await?;

    server.run().await?;
    Ok(())
}
```

## API Endpoints

- `POST /api/v1/auth/login` - Authenticate and get JWT token
- `GET /api/v1/config/:key` - Get configuration value
- `PUT /api/v1/config/:key` - Update configuration value
- `DELETE /api/v1/config/:key` - Delete configuration
- `GET /api/v1/config/:key/history` - Get configuration history
- `GET /health` - Health check endpoint
- `GET /metrics` - Prometheus metrics

## Security Features

- JWT-based authentication
- RBAC authorization
- Rate limiting (100 req/min per client)
- Input validation
- Audit logging
- TLS/HTTPS support

## License

Licensed under the Apache License, Version 2.0.
npm package: @llm-dev-ops/llm-config-audit
Description: Audit logging and compliance tracking (Rust crate - use via cargo or build from source)
Author: LLM DevOps Team
Latest version: 0.5.0

# llm-config-audit

[![Crates.io](https://img.shields.io/crates/v/llm-config-audit.svg)](https://crates.io/crates/llm-config-audit)
[![Documentation](https://docs.rs/llm-config-audit/badge.svg)](https://docs.rs/llm-config-audit)
[![License](https://img.shields.io/crates/l/llm-config-audit.svg)](https://github.com/globalbusinessadvisors/llm-config-manager/blob/main/LICENSE)

Comprehensive audit logging system with tamper-proof logs, change tracking, and compliance reporting for LLM Config Manager.

## Features

- **Tamper-Proof Logging**: Cryptographic hashing of audit entries
- **Change Tracking**: Record all configuration changes with before/after values
- **User Attribution**: Track who made what changes when
- **Compliance Reports**: SOC2, HIPAA, ISO27001 audit trails
- **Query Interface**: Search and filter audit logs

## Usage

```toml
[dependencies]
llm-config-audit = "0.5.0"
```

```rust
use llm_config_audit::{AuditLogger, AuditEvent};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let logger = AuditLogger::new()?;

    // Log an event
    logger.log(AuditEvent {
        user_id: "user123",
        action: "UPDATE",
        resource: "app.database.url",
        old_value: Some("old-url"),
        new_value: Some("new-url"),
        timestamp: Utc::now(),
    }).await?;

    // Query audit logs
    let logs = logger.query()
        .user("user123")
        .since(start_date)
        .execute()
        .await?;

    Ok(())
}
```

## License

Licensed under the Apache License, Version 2.0.
npm package: @llm-dev-ops/llm-config-cache
Description: Caching layer for configuration values (Rust crate - use via cargo or build from source)
Author: LLM DevOps Team
Latest version: 0.5.0

# llm-config-cache

[![Crates.io](https://img.shields.io/crates/v/llm-config-cache.svg)](https://crates.io/crates/llm-config-cache)
[![Documentation](https://docs.rs/llm-config-cache/badge.svg)](https://docs.rs/llm-config-cache)
[![License](https://img.shields.io/crates/l/llm-config-cache.svg)](https://github.com/globalbusinessadvisors/llm-config-manager/blob/main/LICENSE)

Multi-tier caching system with L1/L2 cache support, TTL management, and cache invalidation strategies for LLM Config Manager.

## Features

- **Two-Tier Caching**: In-memory L1 cache + persistent L2 cache
- **TTL Management**: Automatic expiration of cached entries
- **Cache Promotion**: Hot entries promoted from L2 to L1
- **Invalidation Strategies**: Pattern-based and namespace-wide invalidation
- **High Performance**: Sub-microsecond L1 access, microsecond L2 access

## Usage

```toml
[dependencies]
llm-config-cache = "0.5.0"
```

```rust
use llm_config_cache::CacheManager;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let cache = CacheManager::new();

    // Cache a value
    cache.put("key", b"value", Some(Duration::from_secs(300))).await?;

    // Retrieve from cache
    if let Some(value) = cache.get("key").await? {
        println!("Cached: {:?}", value);
    }

    Ok(())
}
```

## Performance

- L1 cache hit: ~8 µs
- L2 cache hit: ~50 µs
- Cache miss: Falls through to storage

## License

Licensed under the Apache License, Version 2.0.
npm package: @llm-dev-ops/llm-config-cli
Description: Command-line interface (Rust crate - use via cargo or build from source)
Author: LLM DevOps Team
Latest version: 0.5.0

# llm-config-cli

[![Crates.io](https://img.shields.io/crates/v/llm-config-cli.svg)](https://crates.io/crates/llm-config-cli)
[![Documentation](https://docs.rs/llm-config-cli/badge.svg)](https://docs.rs/llm-config-cli)
[![License](https://img.shields.io/crates/l/llm-config-cli.svg)](https://github.com/globalbusinessadvisors/llm-config-manager/blob/main/LICENSE)

Command-line interface for LLM Config Manager with interactive prompts, colored output, and comprehensive configuration management.

## Features

- **Interactive Mode**: User-friendly prompts for configuration
- **Colored Output**: Syntax highlighting and status colors
- **Batch Operations**: Import/export configurations in bulk
- **Environment Management**: Switch between environments easily
- **Secret Management**: Secure handling of sensitive values
- **Version Control**: View history and rollback changes
- **Format Support**: JSON, YAML, TOML input/output

## Installation

```bash
cargo install llm-config-cli
```

## Usage

### Set Configuration

```bash
# Set a simple value
llm-config set app.database.url postgres://localhost/mydb --env production

# Set a secret (encrypted)
llm-config set-secret app.api.key my-secret-key --env production
```

### Get Configuration

```bash
# Get a value
llm-config get app.database.url --env production

# Get with JSON output
llm-config get app.database.url --env production --format json
```

### List Configurations

```bash
# List all configurations
llm-config list --env production

# List with pattern
llm-config list app.* --env production
```

### Version Control

```bash
# View history
llm-config history app.database.url

# Rollback to previous version
llm-config rollback app.database.url --version 5
```

### Import/Export

```bash
# Export configurations
llm-config export --env production > config.json

# Import configurations
llm-config import config.json --env staging
```

## Configuration

The CLI stores its configuration in `~/.config/llm-config/config.toml`:

```toml
[default]
environment = "development"
format = "json"
storage_path = "~/.local/share/llm-config"
```

## License

Licensed under the Apache License, Version 2.0.
npm package: @llm-dev-ops/llm-config-crypto
Description: Cryptography primitives for LLM Config Manager - AES-256-GCM encryption, key derivation, and secure key management
Latest version: 0.5.0

# llm-config-crypto

[![Crates.io](https://img.shields.io/crates/v/llm-config-crypto.svg)](https://crates.io/crates/llm-config-crypto)
[![Documentation](https://docs.rs/llm-config-crypto/badge.svg)](https://docs.rs/llm-config-crypto)
[![License](https://img.shields.io/crates/l/llm-config-crypto.svg)](https://github.com/globalbusinessadvisors/llm-config-manager/blob/main/LICENSE)

Cryptography primitives for LLM Config Manager providing AES-256-GCM encryption, key derivation, and secure key management.

## Features

- **AES-256-GCM Encryption**: Industry-standard encryption for configuration secrets
- **Secure Key Derivation**: Argon2id-based key derivation from passwords
- **Key Management**: Secure generation, storage, and rotation of encryption keys
- **Zero-Copy Security**: Zeroization of sensitive data in memory
- **ChaCha20-Poly1305**: Alternative cipher for high-performance scenarios

## Usage

Add this to your `Cargo.toml`:

```toml
[dependencies]
llm-config-crypto = "0.5.0"
```

### Basic Example

```rust
use llm_config_crypto::{CryptoManager, KeyDerivation};

// Create a crypto manager
let crypto = CryptoManager::new()?;

// Encrypt sensitive data
let plaintext = b"my-secret-value";
let encrypted = crypto.encrypt(plaintext)?;

// Decrypt data
let decrypted = crypto.decrypt(&encrypted)?;
assert_eq!(plaintext, decrypted.as_slice());
```

### Key Derivation

```rust
use llm_config_crypto::KeyDerivation;

// Derive a key from a password
let password = "my-secure-password";
let salt = KeyDerivation::generate_salt()?;
let key = KeyDerivation::derive_key(password, &salt)?;
```

## Security Features

- **AEAD**: Authenticated encryption with associated data
- **Constant-time operations**: Prevents timing attacks
- **Automatic zeroization**: Sensitive data cleared from memory
- **Secure random**: Cryptographically secure random number generation

## Performance

Benchmarks on modern hardware:
- Encryption (1KB): ~20 µs
- Decryption (1KB): ~20 µs
- Key derivation: ~100 ms (tuned for security)

## Minimum Supported Rust Version

This crate requires Rust 1.75 or later.

## License

Licensed under the Apache License, Version 2.0. See [LICENSE](../../LICENSE) for details.

## Contributing

See [CONTRIBUTING.md](../../docs/CONTRIBUTING.md) for contribution guidelines.
npm package: @llm-dev-ops/llm-config-metrics
Description: Prometheus-based metrics collection (Rust crate - use via cargo or build from source)
Author: LLM DevOps Team
Latest version: 0.5.0

# llm-config-metrics

[![Crates.io](https://img.shields.io/crates/v/llm-config-metrics.svg)](https://crates.io/crates/llm-config-metrics)
[![Documentation](https://docs.rs/llm-config-metrics/badge.svg)](https://docs.rs/llm-config-metrics)
[![License](https://img.shields.io/crates/l/llm-config-metrics.svg)](https://github.com/globalbusinessadvisors/llm-config-manager/blob/main/LICENSE)

Prometheus-based metrics collection and export for monitoring configuration access, performance, and usage patterns in LLM Config Manager.

## Features

- **Prometheus Integration**: Native Prometheus metrics export
- **Performance Metrics**: Request latency, throughput, error rates
- **Usage Tracking**: Configuration access patterns and hot keys
- **Custom Metrics**: Define application-specific metrics
- **Histogram Support**: Detailed latency distribution

## Usage

```toml
[dependencies]
llm-config-metrics = "0.5.0"
```

```rust
use llm_config_metrics::MetricsCollector;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let metrics = MetricsCollector::new();

    // Record metric
    metrics.record_request_duration("get_config", 0.045)?;
    metrics.increment_counter("config_access", &["production"])?;

    // Export metrics (Prometheus format)
    let exported = metrics.export()?;
    println!("{}", exported);

    Ok(())
}
```

## Metrics Provided

- `config_requests_total`: Total configuration requests
- `config_request_duration_seconds`: Request latency histogram
- `config_cache_hits_total`: Cache hit counter
- `config_errors_total`: Error counter by type

## License

Licensed under the Apache License, Version 2.0.
npm package: @llm-dev-ops/llm-config-rbac
Description: Role-Based Access Control (RBAC) system with fine-grained permissions, namespace isolation, and policy enforcement
Latest version: 0.5.0

# llm-config-rbac

[![Crates.io](https://img.shields.io/crates/v/llm-config-rbac.svg)](https://crates.io/crates/llm-config-rbac)
[![Documentation](https://docs.rs/llm-config-rbac/badge.svg)](https://docs.rs/llm-config-rbac)
[![License](https://img.shields.io/crates/l/llm-config-rbac.svg)](https://github.com/globalbusinessadvisors/llm-config-manager/blob/main/LICENSE)

Role-Based Access Control (RBAC) system with fine-grained permissions, namespace isolation, and policy enforcement for LLM Config Manager.

## Features

- **Fine-Grained Permissions**: Read, write, delete, admin permissions per resource
- **Namespace Isolation**: Scope permissions to specific configuration namespaces
- **Role Management**: Define custom roles with specific permission sets
- **Policy Enforcement**: Automatic policy checks before operations
- **User-Role Assignment**: Flexible user-to-role mappings
- **Audit Trail**: Track all authorization decisions

## Usage

```toml
[dependencies]
llm-config-rbac = "0.5.0"
```

```rust
use llm_config_rbac::{RBACManager, Permission, Role};

// Create RBAC manager
let rbac = RBACManager::new();

// Define roles
rbac.create_role("admin", vec![
    Permission::Read,
    Permission::Write,
    Permission::Delete,
    Permission::Admin,
]);

// Assign role to user
rbac.assign_role("user123", "admin", Some("production"))?;

// Check permissions
if rbac.can_write("user123", "app.database.url", "production") {
    // User has write permission
}
```

## License

Licensed under the Apache License, Version 2.0.
npm package: @llm-dev-ops/llm-config-security
Description: Security hardening and validation for LLM Config Manager with input validation, rate limiting, and threat protection
Latest version: 0.5.0

# llm-config-security

[![Crates.io](https://img.shields.io/crates/v/llm-config-security.svg)](https://crates.io/crates/llm-config-security)
[![Documentation](https://docs.rs/llm-config-security/badge.svg)](https://docs.rs/llm-config-security)
[![License](https://img.shields.io/crates/l/llm-config-security.svg)](https://github.com/globalbusinessadvisors/llm-config-manager/blob/main/LICENSE)

Security hardening and validation for LLM Config Manager with input validation, rate limiting, and threat protection.

## Features

- **Input Validation**: Comprehensive validation of user inputs
- **Rate Limiting**: Token bucket algorithm for API protection
- **SQL Injection Prevention**: Detection and blocking of SQL injection attempts
- **XSS Protection**: HTML/JavaScript sanitization
- **CSRF Protection**: Token-based CSRF prevention
- **Password Policies**: Configurable password strength requirements
- **Secret Detection**: Prevent accidental secret exposure

## Usage

```toml
[dependencies]
llm-config-security = "0.5.0"
```

```rust
use llm_config_security::{Validator, RateLimiter};

// Input validation
let validator = Validator::new();
validator.validate_key("app.database.url")?;
validator.validate_value("SELECT * FROM users")?;

// Rate limiting
let limiter = RateLimiter::new(100, Duration::from_secs(60));
if limiter.check_rate_limit(&client_id).await? {
    // Allow request
}
```

## Security Features

- OWASP Top 10 protections
- Constant-time comparisons
- Secure random generation
- Automatic secret redaction
- Security headers enforcement

## License

Licensed under the Apache License, Version 2.0.
npm package: @llm-dev-ops/llm-config-storage
Description: Persistent storage backend using embedded Sled database (Rust crate - use via cargo or build from source)
Author: LLM DevOps Team
Latest version: 0.5.0

# llm-config-storage

[![Crates.io](https://img.shields.io/crates/v/llm-config-storage.svg)](https://crates.io/crates/llm-config-storage)
[![Documentation](https://docs.rs/llm-config-storage/badge.svg)](https://docs.rs/llm-config-storage)
[![License](https://img.shields.io/crates/l/llm-config-storage.svg)](https://github.com/globalbusinessadvisors/llm-config-manager/blob/main/LICENSE)

Persistent storage backend for LLM Config Manager using embedded Sled database with encryption support.

## Features

- **Embedded Database**: Zero-config Sled database for persistent storage
- **Encryption at Rest**: Automatic encryption of sensitive configuration data
- **ACID Transactions**: Atomic, consistent, isolated, durable operations
- **Namespace Isolation**: Separate storage for different configuration namespaces
- **Version History**: Store and retrieve historical configuration versions
- **Backup & Restore**: Built-in backup and restore capabilities

## Usage

Add this to your `Cargo.toml`:

```toml
[dependencies]
llm-config-storage = "0.5.0"
llm-config-crypto = "0.5.0"
```

### Basic Example

```rust
use llm_config_storage::StorageBackend;
use llm_config_crypto::CryptoManager;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize storage with encryption
    let crypto = CryptoManager::new()?;
    let storage = StorageBackend::open("./data", Some(crypto))?;

    // Store configuration
    storage.put("app.database.url", b"postgres://localhost/mydb").await?;

    // Retrieve configuration
    let value = storage.get("app.database.url").await?;

    Ok(())
}
```

### Namespace Management

```rust
// Create namespace-specific storage
let namespace = storage.namespace("production");
namespace.put("api.key", b"secret-key").await?;
```

## Storage Format

- **Key-Value Store**: Simple and efficient key-value access
- **JSON/Binary**: Supports both JSON and binary value storage
- **Compression**: Optional compression for large values
- **Encryption**: Transparent encryption layer for sensitive data

## Performance

Benchmarks on modern hardware:
- Read operations: ~10 µs per key
- Write operations: ~50 µs per key
- Batch writes: ~5000 ops/sec

## Minimum Supported Rust Version

This crate requires Rust 1.75 or later.

## License

Licensed under the Apache License, Version 2.0. See [LICENSE](../../LICENSE) for details.

## Contributing

See [CONTRIBUTING.md](../../docs/CONTRIBUTING.md) for contribution guidelines.
npm package: @llm-dev-ops/llm-config-templates
Description: Configuration template system with variable substitution, inheritance, and environment-specific overrides
Latest version: 0.5.0

# llm-config-templates

[![Crates.io](https://img.shields.io/crates/v/llm-config-templates.svg)](https://crates.io/crates/llm-config-templates)
[![Documentation](https://docs.rs/llm-config-templates/badge.svg)](https://docs.rs/llm-config-templates)
[![License](https://img.shields.io/crates/l/llm-config-templates.svg)](https://github.com/globalbusinessadvisors/llm-config-manager/blob/main/LICENSE)

Configuration template system with variable substitution, inheritance, and environment-specific overrides for LLM Config Manager.

## Features

- **Variable Substitution**: Use `${VAR}` syntax for dynamic values
- **Template Inheritance**: Extend base templates with overrides
- **Environment-Specific**: Different templates per environment
- **Validation**: Type checking and constraint validation

## Usage

```toml
[dependencies]
llm-config-templates = "0.5.0"
```

```rust
use llm_config_templates::TemplateEngine;

let engine = TemplateEngine::new();

// Define a template
let template = r#"
database_url = "${DB_HOST}:${DB_PORT}/${DB_NAME}"
max_connections = ${MAX_CONNS}
"#;

// Render with variables
let rendered = engine.render(template, &vars)?;
```

## License

Licensed under the Apache License, Version 2.0.
npm package: @llm-dev-ops/llm-schema-api
Description: LLM Schema API - Core API server for schema registry
Author: Schema Registry Team
Latest version: 0.1.0

# @llm-dev-ops/llm-schema-api

LLM Schema API - Core API server for schema registry with gRPC support

## Installation

```bash
npm install -g @llm-dev-ops/llm-schema-api
```

## Usage

```bash
# Start the API server
llm-schema-api

# Start with custom configuration
llm-schema-api --config /path/to/config.yaml

# View help
llm-schema-api --help
```

## Configuration

The API server can be configured using environment variables or a configuration file:

```yaml
# Server configuration
server:
  grpc_port: 50051
  host: "0.0.0.0"

# Database
database:
  url: "postgresql://user:password@localhost/schema_registry"
  max_connections: 20

# Storage backend
storage:
  type: "postgres"  # postgres, s3, or hybrid

# Cache settings
cache:
  enabled: true
  redis_url: "redis://localhost:6379"
  ttl_seconds: 300
```

## Features

- High-performance gRPC API
- Protocol Buffer definitions for schemas
- PostgreSQL storage with S3 backup
- Redis caching for fast lookups
- Streaming support for large schemas
- Schema versioning and compatibility checking
- Authentication and authorization
- Metrics and observability

## gRPC Services

The API provides the following gRPC services:

### SchemaRegistry Service

- `RegisterSchema` - Register a new schema version
- `GetSchema` - Retrieve a schema by namespace, name, and version
- `ListSchemas` - List schemas in a namespace
- `DeleteSchema` - Delete a schema version
- `ValidateData` - Validate data against a schema
- `CheckCompatibility` - Check compatibility between schema versions

### Admin Service

- `GetMetrics` - Retrieve server metrics
- `HealthCheck` - Check server health
- `GetConfig` - Get server configuration

## Documentation

For more information, visit: https://github.com/globalbusinessadvisors/llm-schema-registry

## License

Apache-2.0
npm package: @llm-dev-ops/llm-schema-registry-cli
Description: Command-line interface for LLM Schema Registry
Author: Schema Registry Team
Latest version: 0.1.0

# @llm-dev-ops/llm-schema-registry-cli

Command-line interface for the LLM Schema Registry.

## Installation

```bash
npm install -g @llm-dev-ops/llm-schema-registry-cli
```

## Usage

```bash
# Register a schema
llm-schema register --namespace myapp --name user-schema --version 1.0.0 --file schema.json

# Get a schema
llm-schema get --namespace myapp --name user-schema --version 1.0.0

# Validate data against a schema
llm-schema validate --namespace myapp --name user-schema --version 1.0.0 --data data.json

# List all schemas
llm-schema list --namespace myapp

# Check compatibility
llm-schema compat --namespace myapp --name user-schema --file new-schema.json
```

## Features

- Full CRUD operations for schemas
- Schema validation
- Compatibility checking
- Interactive and scriptable modes
- Supports JSON Schema, Avro, and Protobuf

## Documentation

For more information, visit: https://github.com/globalbusinessadvisors/llm-schema-registry

## License

Apache-2.0
npm package: @llm-dev-ops/llm-schema-registry-integrations
Description: LLM framework integrations for Schema Registry (LangChain, LlamaIndex, vLLM)
Author: Schema Registry Team
Latest version: 0.1.0

# @llm-dev-ops/llm-schema-registry-integrations

LLM framework integrations for Schema Registry (LangChain, LlamaIndex, vLLM)

## Installation

```bash
npm install @llm-dev-ops/llm-schema-registry-integrations
```

## Usage

### LangChain Integration

```typescript
import { SchemaRegistryClient } from '@llm-dev-ops/llm-schema-registry-sdk';
import { createLangChainValidator } from '@llm-dev-ops/llm-schema-registry-integrations';

const client = new SchemaRegistryClient({
  baseURL: 'http://localhost:8080',
  apiKey: 'your-api-key'
});

const validator = createLangChainValidator(
  client,
  'myapp',
  'user-schema',
  '1.0.0'
);

// Validate chain output
const result = await validator.validateChainOutput({
  name: 'John Doe',
  email: 'john@example.com'
});

if (result.valid) {
  console.log('Output is valid!');
} else {
  console.error('Validation errors:', result.errors);
}
```

### LlamaIndex Integration

```typescript
import { SchemaRegistryClient } from '@llm-dev-ops/llm-schema-registry-sdk';
import { createLlamaIndexValidator } from '@llm-dev-ops/llm-schema-registry-integrations';

const client = new SchemaRegistryClient({
  baseURL: 'http://localhost:8080',
  apiKey: 'your-api-key'
});

const validator = createLlamaIndexValidator(
  client,
  'myapp',
  'document-schema',
  '1.0.0'
);

// Validate query response
const result = await validator.validateQueryResponse({
  documents: [{ id: '1', content: 'Hello world' }]
});

// Validate index data
const indexResult = await validator.validateIndexData({
  id: '1',
  metadata: { source: 'web' }
});
```

### vLLM Integration

```typescript
import { SchemaRegistryClient } from '@llm-dev-ops/llm-schema-registry-sdk';
import { createVLLMValidator } from '@llm-dev-ops/llm-schema-registry-integrations';

const client = new SchemaRegistryClient({
  baseURL: 'http://localhost:8080',
  apiKey: 'your-api-key'
});

const validator = createVLLMValidator(
  client,
  'myapp',
  'generation-schema',
  '1.0.0'
);

// Validate single model output
const result = await validator.validateModelOutput({
  text: 'Generated response',
  tokens: 42
});

// Validate batch outputs
const batchResults = await validator.validateBatchOutput([
  { text: 'Response 1', tokens: 10 },
  { text: 'Response 2', tokens: 20 }
]);
```

## Features

- Schema validation for LangChain chain outputs
- Schema validation for LlamaIndex query responses and index data
- Schema validation for vLLM model outputs (single and batch)
- Full TypeScript support with type definitions
- Seamless integration with Schema Registry SDK

## Documentation

For more information, visit: https://github.com/globalbusinessadvisors/llm-schema-registry

## License

Apache-2.0
npm package: @llm-dev-ops/llm-schema-registry-server
Description: LLM Schema Registry Server - HTTP/gRPC server for schema management
Author: Schema Registry Team
Latest version: 0.1.0

# @llm-dev-ops/llm-schema-registry-server

LLM Schema Registry Server - HTTP/gRPC server for schema management

## Installation

```bash
npm install -g @llm-dev-ops/llm-schema-registry-server
```

## Usage

```bash
# Start the server with default configuration
llm-schema-server

# Start with custom configuration
llm-schema-server --config /path/to/config.yaml

# Start on a specific port
llm-schema-server --port 8080

# View help
llm-schema-server --help
```

## Configuration

The server can be configured using a YAML configuration file. Example:

```yaml
server:
  http_port: 8080
  grpc_port: 50051
  host: "0.0.0.0"

database:
  postgres:
    url: "postgresql://user:password@localhost/schema_registry"
    max_connections: 10

storage:
  type: "postgres"  # or "s3"

cache:
  enabled: true
  ttl_seconds: 300

security:
  auth_enabled: false
  jwt_secret: "your-secret-key"
```

## Features

- HTTP REST API for schema management
- gRPC API for high-performance access
- PostgreSQL/S3 storage backends
- Built-in caching with Redis support
- JWT authentication
- Prometheus metrics
- OpenTelemetry tracing

## API Endpoints

### HTTP REST API (default port 8080)

- `POST /schemas` - Register a new schema
- `GET /schemas/:namespace/:name/:version` - Get a schema
- `POST /schemas/validate` - Validate data against a schema
- `POST /schemas/compatibility` - Check schema compatibility
- `GET /schemas/:namespace` - List schemas in a namespace
- `DELETE /schemas/:namespace/:name/:version` - Delete a schema

### gRPC API (default port 50051)

See the [API documentation](https://github.com/globalbusinessadvisors/llm-schema-registry) for gRPC service definitions.

## Documentation

For more information, visit: https://github.com/globalbusinessadvisors/llm-schema-registry

## License

Apache-2.0