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 30+ AI providers and 100+ models under one consistent API.

Extracted from production systems at Juspay, NeuroLink provides a practical, TypeScript-first way to integrate AI into any application. Whether you're building with OpenAI, Anthropic, Google, AWS Bedrock, Azure, or any of our 30+ supported providers, NeuroLink gives you a single, consistent interface that works everywhere.

Why NeuroLink? Switch providers with a single parameter change, leverage built-in tools plus any MCP-compliant tool server, 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
Avatar / Music Modalities + 12 Providers	next	New output: { mode: "avatar" | "music" } dispatch with handlers for D-ID, HeyGen, Replicate-MuseTalk (avatar) and Beatoven, ElevenLabs Music, Lyria, Replicate-MusicGen (music). Plus Fish Audio TTS, Kling/Runway/Replicate video, xAI/Groq/Cohere/Together/Fireworks/Perplexity/Cloudflare LLMs, Voyage/Jina embeddings, Stability/Ideogram/Recraft/Replicate image-gen.	Provider Integration
Multi-Provider Voice (TTS/STT)	v9.62.0	6 TTS providers (OpenAI TTS, ElevenLabs, Google TTS, Azure TTS, Fish Audio, Cartesia) + 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 | fish-audio | cartesia
  },
});
// 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"],
});

---

Previous Updates (Q3–Q4 2025)

• 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 HITL (Human-in-the-Loop) 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	Audit logging to support your compliance program (HIPAA / SOC 2 / 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 30+ 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, john@example.com",
  },
  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: "john@example.com" }

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 30+ 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 shipped and documented.

🤖 AI Provider Integration

30+ 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	300+ 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 30+ 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

External MCP servers — connect any MCP-compliant server via neurolink mcp add; 11 popular servers (GitHub, PostgreSQL, Google Drive, Slack, and more) ship with ready-made configs:

// 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 30+ AI providers

📖 File Processors Guide - Complete reference for all file types

---

🏢 Enterprise & Production Features

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:

• ✅ Deployable within SOC 2 Type II environments — NeuroLink itself is not audited or certified
• ✅ Deployable on ISO 27001-certified infrastructure — the certification is your infrastructure's, not NeuroLink's
• ✅ Supports GDPR-conscious data handling (EU-region providers selectable; you own compliance)
• ✅ Deployable in HIPAA-aligned configurations — you are responsible for a compliant setup
• ✅ 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

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 30+ 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	30+ 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	30+ 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 (6 providers: Google, OpenAI, ElevenLabs, Azure, Fish Audio, Cartesia) + 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 - Approval workflows for high-stakes operations
• Interactive CLI Guide - AI development environment
• MCP Tools Showcase - 6 built-in tools & connecting external MCP servers

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 deployment 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

• Real-time chat and community → Discord
• Bug reports and feature requests → GitHub Issues
• New here? Start with a good first issue
• 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.

Acknowledgements

NeuroLink is made possible by the vibrant open-source AI ecosystem. We gratefully acknowledge the teams behind OpenAI, Anthropic, Google AI, Mistral, and the many other providers and open-source projects that power this platform. Special thanks to every contributor who has filed issues, submitted pull requests, or shared feedback — your input drives NeuroLink forward.

---

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