NeuroLink

The pipe layer for the AI nervous system.

AI intelligence flows as streams — tokens, tool calls, memory, voice, documents. NeuroLink is the vascular layer that carries these streams from where they are generated (LLM providers: the neurons) to where they are needed (connectors: the organs).

import { NeuroLink } from "@juspay/neurolink";

const pipe = new NeuroLink();

// Everything is a stream
const result = await pipe.stream({ input: { text: "Hello" } });
for await (const chunk of result.stream) {
  if ("content" in chunk) {
    process.stdout.write(chunk.content);
  }
}

→ Docs · → Quick Start · → npm

🧠 What is NeuroLink?

NeuroLink is the universal AI integration platform that unifies 21+ AI providers and 100+ models under one consistent API.

Extracted from production systems at Juspay and battle-tested at enterprise scale, NeuroLink provides a production-ready solution for integrating AI into any application. Whether you're building with OpenAI, Anthropic, Google, AWS Bedrock, Azure, or any of our 21+ supported providers, NeuroLink gives you a single, consistent interface that works everywhere.

Why NeuroLink? Switch providers with a single parameter change, leverage 64+ built-in tools and MCP servers, deploy with confidence using enterprise features like Redis memory and multi-provider failover, and optimize costs automatically with intelligent routing. Use it via our professional CLI or TypeScript SDK—whichever fits your workflow.

Where we're headed: We're building for the future of AI—edge-first execution and continuous streaming architectures that make AI practically free and universally available. Read our vision →

Get Started in <5 Minutes →

What's New (Q1 2026)

| Feature | Version | Description | Guide | | ---------------------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------- | | Multi-Provider Voice (TTS/STT) | v9.62.0 | 4 TTS providers (OpenAI TTS, ElevenLabs, Google TTS, Azure TTS) + 4 STT providers (Whisper, Deepgram, Azure STT, Google STT) + 2 realtime APIs (OpenAI Realtime, Gemini Live). | TTS Guide | STT Guide | Realtime Guide | | 4 New Providers | v9.60.0 | DeepSeek (V3/R1), NVIDIA NIM (400+ catalog), LM Studio (local), llama.cpp (GGUF local). | Provider Setup | | ModelAccessDeniedError | v9.59.0 | Typed ModelAccessDeniedError + sdk.checkCredentials() API for proactive credential validation before first call. | Error Reference | | Provider Fallback Policy | v9.58.0 | providerFallback callback + modelChain config for centralized multi-provider fallback logic. | Advanced Guide | | Per-Request Credentials | v9.52.0 | Pass credentials per-call or per-instance for all providers. Per-call overrides instance; instance overrides env vars. | Credentials Guide | | AutoResearch | v9.53.0 | Autonomous AI experiment engine: proposes code changes, runs experiments, evaluates metrics — unattended for hours. | AutoResearch Guide | | Gemini 3 Multi-turn Tool Fix | v9.49.0 | Fixed multi-step agentic tool calling on Vertex AI Gemini 3. Correct thoughtSignature replay, stepIndex grouping, executionId session isolation, 5-min timeout. | Vertex AI Guide | | MCP Enhancements | v9.16.0 | Tool routing (6 strategies), result caching (LRU/FIFO/LFU), request batching, annotations, elicitation protocol, multi-server management. | MCP Enhancements Guide | | Memory | v9.12.0 | Per-user condensed memory across conversations. LLM-powered condensation with S3, Redis, or SQLite. | Memory Guide | | Context Window Management | v9.2.0 | 4-stage compaction pipeline with budget gate at 80% usage, per-provider token estimation. | Context Compaction Guide | | Tool Execution Control | v9.3.0 | prepareStep and toolChoice for per-step tool enforcement in multi-step agentic loops. | API Reference | | File Processor System | v9.1.0 | 17+ file type processors with ProcessorRegistry, security sanitization, SVG text injection. | File Processors Guide | | RAG with generate()/stream() | v9.2.0 | Pass rag: { files } for automatic document chunking, embedding, and AI-powered search. 10 chunking strategies, hybrid search, reranking. | RAG Guide |

// Multi-Provider Voice (v9.62.0) — TTS + STT
// Voice is configured via the `tts` / `stt` options on generate() / stream(),
// not via dedicated synthesizeSpeech / transcribeAudio methods.

// Text in, audio out (TTS)
const result = await neurolink.generate({
  input: { text: "Hello from NeuroLink" },
  provider: "vertex",
  tts: {
    enabled: true,
    voice: "en-US-Neural2-C",
    format: "mp3",
    output: "./output.mp3", // optional: save to disk
    provider: "elevenlabs", // optional override: openai-tts | elevenlabs | google-ai | vertex | azure-tts
  },
});
// result.audio: { buffer: Buffer, format: "mp3", ... }

// Audio in (STT), text out
const transcript = await neurolink.generate({
  input: { text: "Transcribe and summarize" },
  provider: "openai",
  stt: {
    enabled: true,
    audio: audioBuffer, // Buffer of the audio file
    provider: "whisper", // whisper | deepgram | google-stt | azure-stt
    language: "en-US",
  },
});

// Real-time bidirectional voice (OpenAI Realtime / Gemini Live)
import { RealtimeProcessor } from "@juspay/neurolink";

await RealtimeProcessor.connect(
  "openai-realtime",
  { provider: "openai-realtime", model: "gpt-4o-realtime-preview" },
  { onAudio, onTranscript, onError, onFunctionCall },
);

// AutoResearch — autonomous experiment loop (v9.53.0)
import { resolveConfig, ResearchWorker } from "@juspay/neurolink/autoresearch";

const config = resolveConfig({
  repoPath: "/path/to/repo",
  mutablePaths: ["train.py"],
  runCommand: "python3 train.py",
  metric: {
    name: "val_bpb",
    direction: "lower",
    pattern: "^val_bpb:\\s+([\\d.]+)",
  },
});
const worker = new ResearchWorker(config);
await worker.initialize("experiment-1");
const result = await worker.runExperimentCycle("Try lower learning rate");

// Provider Fallback Policy (v9.58.0) — fires only on ModelAccessDeniedError
import { NeuroLink, ModelAccessDeniedError } from "@juspay/neurolink";

const neurolink = new NeuroLink({
  // Async callback. Single error arg. Return null to give up,
  // or { provider?, model? } to retry with a substitute.
  providerFallback: async (error) => {
    if (
      error instanceof ModelAccessDeniedError &&
      error.allowedModels?.length
    ) {
      return { model: error.allowedModels[0] };
    }
    return null;
  },
  // Sugar over providerFallback: if no callback is set, NeuroLink walks this list
  // on each access denial. modelChain is `string[]` only (model names; same provider).
  modelChain: ["claude-opus-4-7", "claude-sonnet-4-6", "gpt-4o"],
});

• Sharp image compression (v9.50.0) – Automatic image compression for AI providers via the sharp library; reduces upload bandwidth and bypasses provider size limits.
• Redis URL/TLS (v9.49.0) – Redis URL-based connections with TLS support for secure conversation memory in production.
• TaskManager (v9.41.0) – Scheduled and self-running AI tasks; cron-style execution with state checkpointing.
• Multi-user memory retrieval (v9.40.0) – Per-user memory storage and retrieval with customizable prompts.
• Evaluation Scoring (14 scorers) (v9.37.0) – Modular evaluation system with 14 scorers, pipelines, and CLI for offline quality assessment.
• Browser-compatible bundle (v9.34.0) – Client-side SDK bundle for browser use; no Node.js dependency for the core API.
• Per-call memory control (v9.33.0) – Read/write memory control per generate() and stream() call.
• Server Adapters (v8.43.0) – HTTP server with Hono, Express, Fastify, Koa. Foreground/background modes, route management, OpenAPI generation. → Guide
• External TracerProvider (v8.43.0) – Integrate NeuroLink with existing OpenTelemetry setups. → Guide
• Title Generation Events (v8.38.0) – conversation:titleGenerated event + NEUROLINK_TITLE_PROMPT custom titles. → Guide
• Video Generation with Veo (v8.32.0) – Video generation via Google Veo 3.1 on Vertex AI. 720p/1080p, portrait/landscape. → Guide
• Image Generation (v8.31.0) – Native image generation with Gemini and Imagen models. → Guide
• HTTP/Streamable HTTP Transport (v8.29.0) – Remote MCP servers via HTTP with auth headers, retry, rate limiting. → Guide
• PPT Generation – 35 slide types, 5 themes, optional AI-generated images. Works across all major providers. → Guide
• Structured Output with Zod – Type-safe JSON via schema + output.format: "json". → Guide
• CSV & PDF File Support – Attach CSV/PDF with auto-detection. PDF: native visual analysis on Vertex, Anthropic, Bedrock, AI Studio. → CSV | PDF
• LiteLLM, SageMaker & OpenRouter – 100+ models via LiteLLM, custom endpoints on SageMaker, 300+ via OpenRouter. → LiteLLM | SageMaker
• HITL & Guardrails – Human-in-the-loop approval workflows and content filtering. → HITL | Guardrails
• Redis Conversation Export – Export full session history as JSON for analytics and audit. → Guide

Enterprise Security: Human-in-the-Loop (HITL)

NeuroLink includes a production-ready HITL system for regulated industries and high-stakes AI operations:

| Capability | Description | Use Case | | --------------------------- | --------------------------------------------------------- | ------------------------------------------ | | Tool Approval Workflows | Require human approval before AI executes sensitive tools | Financial transactions, data modifications | | Output Validation | Route AI outputs through human review pipelines | Medical diagnosis, legal documents | | Confidence Thresholds | Automatically trigger human review below confidence level | Critical business decisions | | Complete Audit Trail | Full audit logging for compliance (HIPAA, SOC2, GDPR) | Regulated industries |

import { NeuroLink } from "@juspay/neurolink";

const neurolink = new NeuroLink({
  hitl: {
    enabled: true,
    requireApproval: ["writeFile", "executeCode", "sendEmail"],
    confidenceThreshold: 0.85,
    reviewCallback: async (action, context) => {
      // Custom review logic - integrate with your approval system
      return await yourApprovalSystem.requestReview(action);
    },
  },
});

// AI pauses for human approval before executing sensitive tools
const result = await neurolink.generate({
  input: { text: "Send quarterly report to stakeholders" },
});

Enterprise HITL Guide | Quick Start

📚 Quick Start Guide

This guide will have you generating AI responses in under 5 minutes using either the SDK or CLI.

Installation

Choose your preferred package manager:

# npm
npm install @juspay/neurolink

# pnpm (recommended)
pnpm add @juspay/neurolink

# yarn
yarn add @juspay/neurolink

# CLI only (no installation needed)
npx @juspay/neurolink --help

Configuration

NeuroLink works with 21+ AI providers. You'll need at least one API key to get started:

Option 1: Interactive Setup (Recommended)

# Run the setup wizard to configure providers
pnpm dlx @juspay/neurolink setup

The wizard will guide you through:

• Selecting your preferred AI providers
• Validating API keys
• Setting up configuration files

Option 2: Manual Configuration

Create a .env file in your project root:

# Choose one or more providers
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GOOGLE_AI_API_KEY=...

Free Tier Options:

• Google AI Studio: Get a free API key at aistudio.google.com
• Mistral AI: Free tier available at console.mistral.ai
• Ollama: 100% free local models (requires Ollama installation)

Your First API Call (SDK)

Basic Text Generation:

import { NeuroLink } from "@juspay/neurolink";

// Initialize (auto-selects best available provider from your .env)
const neurolink = new NeuroLink();

// Generate a response
const result = await neurolink.generate({
  input: { text: "Explain quantum computing in simple terms" },
});

console.log(result.content);

Streaming Responses:

// Stream tokens in real-time
const stream = await neurolink.stream({
  input: { text: "Write a haiku about code" },
});
for await (const chunk of stream.stream) {
  if ("content" in chunk) process.stdout.write(chunk.content);
}

Multimodal Input (Images + Text):

const result = await neurolink.generate({
  input: {
    text: "What's in this image?",
    images: ["./photo.jpg"],
  },
});

Using Tools:

// Built-in tools are automatically available
const result = await neurolink.generate({
  input: {
    text: "What time is it and what files are in the current directory?",
  },
  // AI can call getCurrentTime and listDirectory tools
});

Your First API Call (CLI)

Basic Generation:

# Simple text generation
npx @juspay/neurolink generate "Explain TypeScript generics"

# Specify provider and model
npx @juspay/neurolink generate "Hello!" --provider openai --model gpt-4o

# Stream responses
npx @juspay/neurolink stream "Write a story about AI" --provider anthropic

Multimodal Input:

# Analyze images
npx @juspay/neurolink generate "Describe this image" --image photo.jpg

# Process PDFs
npx @juspay/neurolink generate "Summarize this document" --pdf report.pdf

# Combine multiple file types
npx @juspay/neurolink generate "Analyze this data" --file data.xlsx --file config.json

Interactive Loop Mode:

# Start an interactive session with persistent context
npx @juspay/neurolink loop

# Inside loop mode:
> set provider anthropic
> set model claude-opus-4
> generate "Hello, Claude!"
> history  # View conversation history
> exit

Common Use Cases

RAG (Retrieval-Augmented Generation):

// Automatically chunk, embed, and search documents
const result = await neurolink.generate({
  input: { text: "What are the key features mentioned in the documentation?" },
  rag: {
    files: ["./docs/guide.md", "./docs/api.md"],
    chunkSize: 512,
    topK: 5,
  },
});

Structured Output with Zod:

import { z } from "zod";

const schema = z.object({
  name: z.string(),
  age: z.number(),
  email: z.string().email(),
});

const result = await neurolink.generate({
  input: {
    text: "Extract user info: John Doe, 30 years old, [email protected]",
  },
  schema,
  output: { format: "json" },
});

// Parse the structured JSON from result.content
const parsed = schema.parse(JSON.parse(result.content));
console.log(parsed); // { name: "John Doe", age: 30, email: "[email protected]" }

External MCP Servers (GitHub, Slack, etc.):

// Connect to GitHub MCP server
await neurolink.addExternalMCPServer("github", {
  command: "npx",
  args: ["-y", "@modelcontextprotocol/server-github"],
  transport: "stdio",
  env: { GITHUB_TOKEN: process.env.GITHUB_TOKEN },
});

// AI can now interact with GitHub
const result = await neurolink.generate({
  input: { text: 'Create an issue titled "Bug: login fails"' },
});

Next Steps

• Complete Documentation - Comprehensive guides and API reference
• Provider Setup Guide - Configure all 21+ providers
• SDK API Reference - Full TypeScript API documentation
• CLI Command Reference - Complete CLI documentation
• Example Projects - Real-world integration examples
• Advanced Features - Middleware, observability, workflows

Troubleshooting

Issue: "Provider not configured"

• Run npx @juspay/neurolink setup or add provider API key to .env

Issue: Rate limit errors

• Configure multiple providers for redundancy — NeuroLink auto-selects the best available
• Use provider: "litellm" with LiteLLM to proxy across many providers

Issue: Large context overflows

• Enable conversation memory with compaction: new NeuroLink({ conversationMemory: { enabled: true } })
• Use rag option to search documents instead of sending full content

Need help? Check our Troubleshooting Guide or open an issue.

🌟 Complete Feature Set

NeuroLink is a comprehensive AI development platform. Every feature below is production-ready and fully documented.

🤖 AI Provider Integration

21+ providers unified under one API - Switch providers with a single parameter change.

| Provider | Models | Free Tier | Tool Support | Status | Documentation | | --------------------- | -------------------------------------------------------------------------- | --------------- | ------------ | ------------- | ----------------------------------------------------------------------------------------------------------------------------- | | OpenAI | GPT-4o, GPT-4o-mini, o1 | ❌ | ✅ Full | ✅ Production | Setup Guide | | Anthropic | Claude 4.6 Opus/Sonnet, Claude 4.5 Opus/Sonnet/Haiku, Claude 4 Opus/Sonnet | ❌ | ✅ Full | ✅ Production | Setup Guide | Subscription Guide | | Google AI Studio | Gemini 3 Flash/Pro, Gemini 2.5 Flash/Pro | ✅ Free Tier | ✅ Full | ✅ Production | Setup Guide | | AWS Bedrock | Claude, Titan, Llama, Nova | ❌ | ✅ Full | ✅ Production | Setup Guide | | Google Vertex | Gemini 3/2.5 (gemini-3-*-preview) | ❌ | ✅ Full | ✅ Production | Setup Guide | | Azure OpenAI | GPT-4, GPT-4o, o1 | ❌ | ✅ Full | ✅ Production | Setup Guide | | LiteLLM | 100+ models unified | Varies | ✅ Full | ✅ Production | Setup Guide | | AWS SageMaker | Custom deployed models | ❌ | ✅ Full | ✅ Production | Setup Guide | | Mistral AI | Mistral Large, Small | ✅ Free Tier | ✅ Full | ✅ Production | Setup Guide | | Hugging Face | 100,000+ models | ✅ Free | ⚠️ Partial | ✅ Production | Setup Guide | | Ollama | Local models (Llama, Mistral) | ✅ Free (Local) | ⚠️ Partial | ✅ Production | Setup Guide | | OpenAI Compatible | Any OpenAI-compatible endpoint | Varies | ✅ Full | ✅ Production | Setup Guide | | OpenRouter | 200+ Models via OpenRouter | Varies | ✅ Full | ✅ Production | Setup Guide | | DeepSeek | deepseek-chat (V3), deepseek-reasoner (R1) | ❌ | ✅ Full | ✅ Production | Setup Guide | | NVIDIA NIM | Llama 3.3 70B, 400+ catalog models | ❌ | ✅ Full | ✅ Production | Setup Guide | | LM Studio | Any model loaded in LM Studio (local) | ✅ Free (Local) | ✅ Full | ✅ Production | Setup Guide | | llama.cpp | Any GGUF model served by llama-server (local) | ✅ Free (Local) | ✅ Full | ✅ Production | Setup Guide | | OpenAI TTS | TTS-1, TTS-1-HD, GPT-4o Audio | ❌ | N/A | ✅ Production | Setup Guide | | ElevenLabs | Multilingual v2, Turbo v2.5, Flash v2.5 | ✅ Free Tier | N/A | ✅ Production | Setup Guide | | Deepgram | Nova-3, Nova-2, Enhanced, Base (STT) | ✅ Free Tier | N/A | ✅ Production | Setup Guide | | Azure Speech | Azure Cognitive Services TTS + STT | ❌ | N/A | ✅ Production | Setup Guide |

📖 Provider Comparison Guide - Detailed feature matrix and selection criteria 🔬 Provider Feature Compatibility - Test-based compatibility reference for all 19 features across 21+ providers

🔧 Built-in Tools & MCP Integration

6 Core Tools (work across all providers, zero configuration):

| Tool | Purpose | Auto-Available | Documentation | | -------------------- | ------------------------ | ----------------------- | ------------------------------------------ | | getCurrentTime | Real-time clock access | ✅ | Tool Reference | | readFile | File system reading | ✅ | Tool Reference | | writeFile | File system writing | ✅ | Tool Reference | | listDirectory | Directory listing | ✅ | Tool Reference | | calculateMath | Mathematical operations | ✅ | Tool Reference | | websearchGrounding | Google Vertex web search | ⚠️ Requires credentials | Tool Reference |

58+ External MCP Servers supported (GitHub, PostgreSQL, Google Drive, Slack, and more):

// stdio transport - local MCP servers via command execution
await neurolink.addExternalMCPServer("github", {
  command: "npx",
  args: ["-y", "@modelcontextprotocol/server-github"],
  transport: "stdio",
  env: { GITHUB_TOKEN: process.env.GITHUB_TOKEN },
});

// HTTP transport - remote MCP servers via URL
await neurolink.addExternalMCPServer("github-copilot", {
  transport: "http",
  url: "https://api.githubcopilot.com/mcp",
  headers: { Authorization: "Bearer YOUR_COPILOT_TOKEN" },
  timeout: 15000,
  retries: 5,
});

// Tools automatically available to AI
const result = await neurolink.generate({
  input: { text: 'Create a GitHub issue titled "Bug in auth flow"' },
});

MCP Transport Options:

| Transport | Use Case | Key Features | | ----------- | -------------- | ----------------------------------------------- | | stdio | Local servers | Command execution, environment variables | | http | Remote servers | URL-based, auth headers, retries, rate limiting | | sse | Event streams | Server-Sent Events, real-time updates | | websocket | Bi-directional | Full-duplex communication |

📖 MCP Integration Guide - Setup external servers 📖 HTTP Transport Guide - Remote MCP server configuration

🔌 MCP Enhancements

Production-grade MCP capabilities for managing tool calls at scale across multi-server environments:

| Module | Purpose | | ----------------------------- | ---------------------------------------------------------- | | Tool Router | Intelligent routing across servers with 6 strategies | | Tool Cache | Result caching with LRU, FIFO, and LFU eviction | | Request Batcher | Automatic batching of tool calls for throughput | | Tool Annotations | Safety metadata and behavior hints for MCP tools | | Tool Converter | Bidirectional conversion between NeuroLink and MCP formats | | Elicitation Protocol | Interactive user input during tool execution (HITL) | | Multi-Server Manager | Load balancing and failover across server groups | | MCP Server Base | Abstract base class for building custom MCP servers | | Enhanced Tool Discovery | Advanced search and filtering across servers | | Agent & Workflow Exposure | Expose agents and workflows as MCP tools | | Server Capabilities | Resource and prompt management per MCP spec | | Registry Client | Discover and connect to MCP servers from registries | | Tool Integration | End-to-end tool lifecycle with middleware chain | | Elicitation Manager | Manages elicitation flows with validation and timeouts |

import { ToolRouter, ToolCache, RequestBatcher } from "@juspay/neurolink";

// Route tool calls across multiple MCP servers
const router = new ToolRouter({
  strategy: "capability-based",
  servers: [
    { name: "github", url: "https://mcp-github.example.com" },
    { name: "db", url: "https://mcp-postgres.example.com" },
  ],
});

// Cache repeated tool results (LRU, FIFO, or LFU)
const cache = new ToolCache({ strategy: "lru", maxSize: 500, ttl: 60_000 });

// Batch concurrent tool calls for throughput
const batcher = new RequestBatcher({ maxBatchSize: 10, maxWaitMs: 50 });

📖 MCP Enhancements Guide - Full reference for all 14 modules

💻 Developer Experience Features

SDK-First Design with TypeScript, IntelliSense, and type safety:

| Feature | Description | Documentation | | --------------------------- | --------------------------------------------------------------------------------- | --------------------------------------------------------- | | Auto Provider Selection | Intelligent provider fallback | SDK Guide | | Streaming Responses | Real-time token streaming | Streaming Guide | | Conversation Memory | Automatic context management with embedded per-user memory | Memory Guide | | Full Type Safety | Complete TypeScript types | Type Reference | | Error Handling | Graceful provider fallback | Error Guide | | Analytics & Evaluation | Usage tracking, quality scores | Analytics Guide | | Middleware System | Request/response hooks | Middleware Guide | | Framework Integration | Next.js, SvelteKit, Express | Framework Guides | | Extended Thinking | Native thinking/reasoning mode for Gemini 3 and Claude models | Thinking Guide | | RAG Document Processing | rag: { files } on generate/stream with 10 chunking strategies and hybrid search | RAG Guide |

📁 Multimodal & File Processing

17+ file categories supported (50+ total file types including code languages) with intelligent content extraction and provider-agnostic processing:

| Category | Supported Types | Processing | | ------------- | ---------------------------------------------------------- | ----------------------------------- | | Documents | Excel (.xlsx, .xls), Word (.docx), RTF, OpenDocument | Sheet extraction, text extraction | | Data | JSON, YAML, XML | Validation, syntax highlighting | | Markup | HTML, SVG, Markdown, Text | OWASP-compliant sanitization | | Code | 50+ languages (TypeScript, Python, Java, Go, etc.) | Language detection, syntax metadata | | Config | .env, .ini, .toml, .cfg | Secure parsing | | Media | Images (PNG, JPEG, WebP, GIF), PDFs, CSV | Provider-specific formatting |

// Process any supported file type
const result = await neurolink.generate({
  input: {
    text: "Analyze this data and code",
    files: [
      "./data.xlsx", // Excel spreadsheet
      "./config.yaml", // YAML configuration
      "./diagram.svg", // SVG (injected as sanitized text)
      "./main.py", // Python source code
    ],
  },
});

// CLI: Use --file for any supported type
// neurolink generate "Analyze this" --file ./report.xlsx --file ./config.json

Key Features:

• ProcessorRegistry - Priority-based processor selection with fallback
• OWASP Security - HTML/SVG sanitization prevents XSS attacks
• Auto-detection - FileDetector identifies file types by extension and content
• Provider-agnostic - All processors work across all 21+ AI providers

📖 File Processors Guide - Complete reference for all file types

🏢 Enterprise & Production Features

Production-ready capabilities for regulated industries:

| Feature | Description | Use Case | Documentation | | --------------------------- | ------------------------------------------- | ------------------------- | ----------------------------------------------------------- | | Enterprise Proxy | Corporate proxy support | Behind firewalls | Proxy Setup | | Redis Memory | Distributed conversation state | Multi-instance deployment | Redis Guide | | Memory | Per-user condensed memory (S3/Redis/SQLite) | Long-term user context | Memory Guide | | Cost Optimization | Automatic cheapest model selection | Budget control | Cost Guide | | Multi-Provider Failover | Automatic provider switching | High availability | Failover Guide | | Telemetry & Monitoring | OpenTelemetry integration | Observability | Telemetry Guide | | Security Hardening | Credential management, auditing | Compliance | Security Guide | | Custom Model Hosting | SageMaker integration | Private models | SageMaker Guide | | Load Balancing | LiteLLM proxy integration | Scale & routing | Load Balancing |

Security & Compliance:

• ✅ SOC2 Type II compliant deployments
• ✅ ISO 27001 certified infrastructure compatible
• ✅ GDPR-compliant data handling (EU providers available)
• ✅ HIPAA compatible (with proper configuration)
• ✅ Hardened OS verified (SELinux, AppArmor)
• ✅ Zero credential logging
• ✅ Encrypted configuration storage
• ✅ Automatic context window management with 4-stage compaction pipeline and 80% budget gate

📖 Enterprise Deployment Guide - Complete production checklist

Enterprise Persistence: Redis Memory

Production-ready distributed conversation state for multi-instance deployments:

Capabilities

| Feature | Description | Benefit | | ---------------------- | -------------------------------------------- | --------------------------- | | Distributed Memory | Share conversation context across instances | Horizontal scaling | | Session Export | Export full history as JSON | Analytics, debugging, audit | | Auto-Detection | Automatic Redis discovery from environment | Zero-config in containers | | Graceful Failover | Falls back to in-memory if Redis unavailable | High availability | | TTL Management | Configurable session expiration | Memory management |

Quick Setup

import { NeuroLink } from "@juspay/neurolink";

// Auto-detect Redis from REDIS_URL environment variable
const neurolink = new NeuroLink({
  conversationMemory: {
    enabled: true,
    enableSummarization: true,
  },
});

// Or explicit Redis configuration
const neurolinkExplicit = new NeuroLink({
  conversationMemory: {
    enabled: true,
    redisConfig: {
      host: "redis.example.com",
      port: 6379,
      password: process.env.REDIS_PASSWORD,
      ttl: 86400, // 24-hour session expiration (seconds)
    },
  },
});

// Retrieve conversation history for analytics
const history = await neurolink.getConversationHistory("session-id");
await saveToDataWarehouse(history);

Docker Quick Start

# Start Redis
docker run -d --name neurolink-redis -p 6379:6379 redis:7-alpine

# Configure NeuroLink
export REDIS_URL=redis://localhost:6379

# Start your application
node your-app.js

Redis Setup Guide | Production Configuration | Migration Patterns

🎨 Professional CLI

15+ commands for every workflow:

| Command | Purpose | Example | Documentation | | ---------------- | ------------------------------------ | -------------------------- | ----------------------------------------- | | setup | Interactive provider configuration | neurolink setup | Setup Guide | | generate | Text generation | neurolink gen "Hello" | Generate | | stream | Streaming generation | neurolink stream "Story" | Stream | | status | Provider health check | neurolink status | Status | | loop | Interactive session | neurolink loop | Loop | | mcp | MCP server management | neurolink mcp discover | MCP CLI | | models | Model listing | neurolink models | Models | | eval | Model evaluation | neurolink eval | Eval | | serve | Start HTTP server in foreground mode | neurolink serve | Serve | | server start | Start HTTP server in background mode | neurolink server start | Server | | server stop | Stop running background server | neurolink server stop | Server | | server status | Show server status information | neurolink server status | Server | | server routes | List all registered API routes | neurolink server routes | Server | | server config | View or modify server configuration | neurolink server config | Server | | server openapi | Generate OpenAPI specification | neurolink server openapi | Server | | rag chunk | Chunk documents for RAG | neurolink rag chunk f.md | RAG CLI |

RAG flags are available on generate and stream: --rag-files, --rag-strategy, --rag-chunk-size, --rag-chunk-overlap, --rag-top-k

📖 Complete CLI Reference - All commands and options

🤖 GitHub Action

Run AI-powered workflows directly in GitHub Actions with 21+ provider support and automatic PR/issue commenting.

- uses: juspay/neurolink@v1
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    prompt: "Review this PR for security issues and code quality"
    post_comment: true

| Feature | Description | | ---------------------- | ----------------------------------------------------------------------------------------- | | Multi-Provider | 21+ providers with unified interface | | PR/Issue Comments | Auto-post AI responses with intelligent updates | | Multimodal Support | Attach images, PDFs, CSVs, Excel, Word, JSON, YAML, XML, HTML, SVG, code files to prompts | | Cost Tracking | Built-in analytics and quality evaluation | | Extended Thinking | Deep reasoning with thinking tokens |

📖 GitHub Action Guide - Complete setup and examples

💰 Smart Model Selection

NeuroLink features intelligent model selection and cost optimization:

Cost Optimization Features

• 💰 Automatic Cost Optimization: Selects cheapest models for simple tasks
• 🔄 LiteLLM Model Routing: Access 100+ models with automatic load balancing
• 🔍 Capability-Based Selection: Find models with specific features (vision, function calling)
• ⚡ Intelligent Fallback: Seamless switching when providers fail

# Cost optimization - automatically use cheapest model
npx @juspay/neurolink generate "Hello" --optimize-cost

# LiteLLM specific model selection
npx @juspay/neurolink generate "Complex analysis" --provider litellm --model "anthropic/claude-sonnet-4-6"

# Auto-select best available provider
npx @juspay/neurolink generate "Write code" # Automatically chooses optimal provider

Revolutionary Interactive CLI

NeuroLink's CLI goes beyond simple commands - it's a full AI development environment:

Why Interactive Mode Changes Everything

| Feature | Traditional CLI | NeuroLink Interactive | | ------------- | ----------------- | ------------------------------ | | Session State | None | Full persistence | | Memory | Per-command | Conversation-aware | | Configuration | Flags per command | /set persists across session | | Tool Testing | Manual per tool | Live discovery & testing | | Streaming | Optional | Real-time default |

Live Demo: Development Session

$ npx @juspay/neurolink loop --enable-conversation-memory

neurolink > /set provider vertex
✓ provider set to vertex (Gemini 3 support enabled)

neurolink > /set model gemini-3-flash-preview
✓ model set to gemini-3-flash-preview

neurolink > Analyze my project architecture and suggest improvements

✓ Analyzing your project structure...
[AI provides detailed analysis, remembering context]

neurolink > Now implement the first suggestion
[AI remembers previous context and implements suggestion]

neurolink > /mcp discover
✓ Discovered 58 MCP tools:
   GitHub: create_issue, list_repos, create_pr...
   PostgreSQL: query, insert, update...
   [full list]

neurolink > Use the GitHub tool to create an issue for this improvement
✓ Creating issue... (requires HITL approval if configured)

neurolink > /export json > session-2026-01-01.json
✓ Exported 15 messages to session-2026-01-01.json

neurolink > exit
Session saved. Resume with: neurolink loop --session session-2026-01-01.json

Session Commands Reference

| Command | Purpose | | -------------------- | ---------------------------------------------------- | | /set <key> <value> | Persist configuration (provider, model, temperature) | | /mcp discover | List all available MCP tools | | /export json | Export conversation to JSON | | /history | View conversation history | | /clear | Clear context while keeping settings |

Interactive CLI Guide | CLI Reference

Skip the wizard and configure manually? See docs/getting-started/provider-setup.md.

CLI & SDK Essentials

neurolink CLI mirrors the SDK so teams can script experiments and codify them later.

# Discover available providers and models
npx @juspay/neurolink status
npx @juspay/neurolink models list --provider google-ai

# Route to a specific provider/model
npx @juspay/neurolink generate "Summarize customer feedback" \
  --provider azure --model gpt-4o-mini

# Turn on analytics + evaluation for observability
npx @juspay/neurolink generate "Draft release notes" \
  --enable-analytics --enable-evaluation --format json

# RAG: Ask questions about your docs (auto-chunks, embeds, searches)
npx @juspay/neurolink generate "What are the key features?" \
  --rag-files ./docs/guide.md ./docs/api.md --rag-strategy markdown

# Claude proxy + local OpenObserve dashboard
npx @juspay/neurolink proxy setup
npx @juspay/neurolink proxy telemetry setup
npx @juspay/neurolink proxy status --format json

import { NeuroLink } from "@juspay/neurolink";

const neurolink = new NeuroLink({
  conversationMemory: {
    enabled: true,
  },
  enableOrchestration: true,
});

const result = await neurolink.generate({
  input: {
    text: "Create a comprehensive analysis",
    files: [
      "./sales_data.csv", // Auto-detected as CSV
      "examples/data/invoice.pdf", // Auto-detected as PDF
      "./diagrams/architecture.png", // Auto-detected as image
      "./report.xlsx", // Auto-detected as Excel
      "./config.json", // Auto-detected as JSON
      "./diagram.svg", // Auto-detected as SVG (injected as text)
      "./app.ts", // Auto-detected as TypeScript code
    ],
  },
  provider: "vertex", // PDF-capable provider (see docs/features/pdf-support.md)
  enableEvaluation: true,
  region: "us-east-1",
});

console.log(result.content);
console.log(result.evaluation?.overallScore);

// RAG: Ask questions about your documents
const answer = await neurolink.generate({
  input: { text: "What are the main architectural decisions?" },
  rag: {
    files: ["./docs/architecture.md", "./docs/decisions.md"],
    strategy: "markdown",
    topK: 5,
  },
});
console.log(answer.content); // AI searches your docs and answers

Gemini 3 with Extended Thinking

import { NeuroLink } from "@juspay/neurolink";

const neurolink = new NeuroLink();

// Use Gemini 3 with extended thinking for complex reasoning
const result = await neurolink.generate({
  input: {
    text: "Solve this step by step: What is the optimal strategy for...",
  },
  provider: "vertex",
  model: "gemini-3-flash-preview",
  thinkingConfig: {
    thinkingLevel: "medium", // Options: "minimal", "low", "medium", "high"
  },
});

console.log(result.content);

Full command and API breakdown lives in docs/cli/commands.md and docs/sdk/api-reference.md.

Platform Capabilities at a Glance

| Capability | Highlights | | ------------------------ | ------------------------------------------------------------------------------------------------------------------------ | | Provider unification | 21+ providers with automatic fallback, cost-aware routing, providerFallback policy, modelChain config. | | Multimodal pipeline | Stream images + CSV data + PDF documents across providers with local/remote assets. Auto-detection for mixed file types. | | Voice pipeline | TTS (4 providers) + STT (4 providers) + realtime voice APIs (OpenAI Realtime, Gemini Live). | | Quality & governance | Auto-evaluation engine (14 scorers), guardrails middleware, HITL workflows, audit logging. | | Memory & context | Per-user condensed memory (S3/Redis/SQLite), Redis session export, 4-stage context compaction. | | CLI tooling | Loop sessions, setup wizard, config validation, Redis auto-detect, JSON output, TTS/STT flags. | | Enterprise ops | Claude proxy, OTLP observability, OpenObserve dashboard, regional routing, credential management. | | Tool ecosystem | MCP auto discovery, HTTP/stdio/SSE/WebSocket transports, LiteLLM hub access, SageMaker custom deployment, web search. |

Documentation Map

| Area | When to Use | Link | | --------------- | --------------------------------------------------------- | ---------------------------------------------------------------- | | Getting started | Install, configure, run first prompt | docs/getting-started/index.md | | Feature guides | Understand new functionality front-to-back | docs/features/index.md | | CLI reference | Command syntax, flags, loop sessions | docs/cli/index.md | | SDK reference | Classes, methods, options | docs/sdk/index.md | | RAG | Document chunking, hybrid search, reranking, rag:{} API | docs/features/rag.md | | Integrations | LiteLLM, SageMaker, MCP | docs/litellm-integration.md | | Advanced | Middleware, architecture, streaming patterns | docs/advanced/index.md | | Cookbook | Practical recipes for common patterns | docs/cookbook/index.md | | Guides | Migration, Redis, troubleshooting, provider selection | docs/guides/index.md | | Operations | Configuration, troubleshooting, provider matrix | docs/reference/index.md |

New in 2026: Enhanced Documentation

Enterprise Features:

• Enterprise HITL Guide - Production-ready approval workflows
• Interactive CLI Guide - AI development environment
• MCP Tools Showcase - 58+ external tools & 6 built-in tools

Provider Intelligence:

• Provider Capabilities Audit - Technical capabilities matrix
• Provider Selection Guide - Interactive decision wizard
• Provider Comparison - Feature & cost comparison

Middleware System:

• Middleware Architecture - Complete lifecycle & patterns
• Built-in Middleware - Analytics, Guardrails, Evaluation
• Custom Middleware Guide - Build your own

Redis & Persistence:

• Redis Quick Start - 5-minute setup
• Redis Configuration - Production-ready setup
• Redis Migration - Migration patterns

Migration Guides:

• From LangChain - Complete migration guide
• From Vercel AI SDK - Next.js focused

Developer Experience:

• Cookbook - 10 practical recipes
• Troubleshooting Guide - Common issues & solutions

Integrations

• LiteLLM 100+ model hub – Unified access to third-party models via LiteLLM routing. → docs/litellm-integration.md
• Amazon SageMaker – Deploy and call custom endpoints directly from NeuroLink CLI/SDK. → docs/sagemaker-integration.md
• Enterprise proxy & security – Configure outbound policies and compliance posture. → docs/enterprise-proxy-setup.md
• Configuration automation – Manage environments, regions, and credentials safely. → docs/configuration-management.md
• MCP tool ecosystem – Auto-discover Model Context Protocol tools and extend workflows. → docs/advanced/mcp-integration.md
• Remote MCP via HTTP – Connect to HTTP-based MCP servers with authentication, retries, and rate limiting. → docs/mcp-http-transport.md

Contributing & Support

• Bug reports and feature requests → GitHub Issues
• Questions and discussions → GitHub Discussions
• Development workflow, testing, and pull request guidelines → docs/development/contributing.md
• Documentation improvements → open a PR referencing the documentation matrix.

NeuroLink is built with ❤️ by Juspay. Contributions, questions, and production feedback are always welcome.