NeuroLink

🧠 NeuroLink

The Pipe Layer of an AI Nervous System

NeuroLink is the pipe layer of an AI nervous system: one interface connecting provider neurons — major AI vendors and local runtimes — to the applications that consume them. Built-in tooling and an opinionated factory architecture mean adding a new provider, or a new capability, never touches application code. NeuroLink ships as both a TypeScript SDK and a professional CLI so teams can build, operate, and iterate on AI features quickly.

🧠 What is NeuroLink?

NeuroLink is the pipe layer of an AI nervous system. Providers — OpenAI, Anthropic, Google, AWS, Azure, DeepSeek, NVIDIA NIM, local runtimes like Ollama and llama.cpp, and dozens more — are the neurons: each generates a different kind of intelligence, at a different cost and latency. NeuroLink is the vascular layer that carries that intelligence, as a stream, to the applications that consume it, across three inference types: generate and stream produce text, decide produces a calibrated boolean/choice/score judgment instead.

Extracted from production systems at Juspay, NeuroLink provides a practical, TypeScript-first way to plug any application into that nervous system. Switch which neuron answers a request with a single parameter change — any provider you're building with, or any provider you add.

Why NeuroLink? Three genuine inference types, not one dressed up three ways — generate and stream produce text, while decide returns a typed, calibrated judgment (boolean / choice / score) with no text at all, for the routing and gating decisions the other two were never meant to make. Every neuron plugs into the same pipe. 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
`decide` Inference Type	next	A third inference type alongside `generate`/`stream`: typed, calibrated `boolean`/`choice`/`score` judgments in one parallel pass, ~400ms and ~$0.00002 per decision. First provider is TypeSafe Jev; Laya, an open-weights model you run yourself, is the second. Fail-open — a no-op without a key.	Decide Guide \| TypeSafe Provider \| Laya Provider
MCP Enhancements	v9.16.0	Advanced MCP features: intelligent tool routing, result caching, request batching, tool annotations, elicitation protocol, custom server creation, multi-server management	MCP Enhancements Guide
Context Compaction	v9.2.0	5-stage compaction pipeline (relevance, prune, deduplicate, summarize, truncate) with auto-detection, budget gate at 80% usage, per-provider token estimation	Context Compaction Guide
File Processor System	v9.1.0	17 file processors across 6 categories with ProcessorRegistry, security sanitization, SVG text injection	File Processors Guide
Workflow Engine	v8.42.0	Multi-model orchestration with consensus, multi-judge, fallback, and adaptive workflows. Ensemble execution with intelligent scoring and evaluation.	Workflow HLD \| Workflow LLD
Docusaurus Documentation	v8.41.0	Migrated from MkDocs to Docusaurus v3 with enhanced search, versioning, and modern UI. Automated doc syncing and LLM-friendly documentation.	Documentation Site
Image Generation with Gemini	v8.31.0	Native image generation using Gemini 2.0 Flash Experimental (`imagen-3.0-generate-002`). High-quality image synthesis directly from Google AI.	Image Generation Guide
HTTP/Streamable HTTP Transport	v8.29.0	Connect to remote MCP servers via HTTP with authentication headers, automatic retry with exponential backoff, and configurable rate limiting.	HTTP Transport Guide

External TracerProvider Support -- Integrate NeuroLink with applications that already have OpenTelemetry instrumentation. Supports auto-detection and manual configuration. -> Observability Guide
Server Adapters -- Deploy NeuroLink as an HTTP API server with your framework of choice (Hono, Express, Fastify, Koa). Full CLI support with serve and server commands for foreground/background modes, route management, and OpenAPI generation. -> Server Adapters Guide
Title Generation Events -- Emit real-time events when conversation titles are auto-generated. Listen to conversation:titleGenerated for session tracking. -> Conversation Memory Guide
Custom Title Prompts -- Customize conversation title generation with NEUROLINK_TITLE_PROMPT environment variable. Use ${userMessage} placeholder for dynamic prompts. -> Conversation Memory Guide
Video Generation -- Transform images into 8-second videos with synchronized audio using Google Veo 3.1 via Vertex AI. Supports 720p/1080p resolutions, portrait/landscape aspect ratios. -> Video Generation Guide
Image Generation -- Generate images from text prompts using Gemini models via Vertex AI or Google AI Studio. Supports streaming mode with automatic file saving. -> Image Generation Guide
HTTP/Streamable HTTP Transport for MCP -- Connect to remote MCP servers via HTTP with authentication headers, retry logic, and rate limiting. -> HTTP Transport Guide
Claude Subscription (OAuth) Support -- Use your Claude Pro/Max/Team subscription with NeuroLink via OAuth authentication, no API key required. -> Subscription Guide
Gemini 3 Preview Support - Full support for gemini-3-flash-preview and gemini-3-pro-preview with extended thinking capabilities
Structured Output with Zod Schemas -- Type-safe JSON generation with automatic validation using schema + output.format: "json" in generate(). -> Structured Output Guide
CSV File Support -- Attach CSV files to prompts for AI-powered data analysis with auto-detection. -> CSV Guide
PDF File Support -- Process PDF documents with native visual analysis for Vertex AI, Anthropic, Bedrock, AI Studio. -> PDF Guide
50+ File Types -- Process Excel, Word, RTF, JSON, YAML, XML, HTML, SVG, Markdown, and 50+ code languages with intelligent content extraction. -> File Processors Guide
LiteLLM Integration -- Access 100+ AI models across a broad range of AI providers through unified interface. -> Setup Guide
SageMaker Integration -- Deploy and use custom trained models on AWS infrastructure. -> Setup Guide
OpenRouter Integration -- Access 300+ models from OpenAI, Anthropic, Google, Meta, and more through a single unified API. -> Setup Guide
Human-in-the-loop workflows -- Pause generation for user approval/input before tool execution. -> HITL Guide
Guardrails middleware -- Block PII, profanity, and unsafe content with built-in filtering. -> Guardrails Guide
Context summarization -- Automatic conversation compression for long-running sessions. -> Summarization Guide
Redis conversation export -- Export full session history as JSON for analytics and debugging. -> History Guide

// Multi-Model Workflow Engine (v8.42.0)
import { NeuroLink } from "@juspay/neurolink";

const neurolink = new NeuroLink();

// Run a consensus workflow with multiple models
const result = await neurolink.runConsensusWorkflow({
  prompt: "Explain quantum computing",
  models: [
    { provider: "anthropic", modelId: "claude-sonnet-4-6" },
    { provider: "openai", modelId: "gpt-4o" },
    { provider: "google-ai", modelId: "gemini-3-flash-preview" },
  ],
  judgeModel: { provider: "anthropic", modelId: "claude-opus-4-7" },
  options: { temperature: 0.7 },
});

console.log(result.response); // Best response selected by judge
console.log(result.score); // Quality score (0-100)
console.log(result.metrics); // Detailed performance metrics

// Image Generation with Gemini (v8.31.0)
const image = await neurolink.generateImage({
  prompt: "A futuristic cityscape",
  provider: "google-ai",
  model: "imagen-3.0-generate-002",
});

// HTTP Transport for Remote MCP (v8.29.0)
await neurolink.addExternalMCPServer("remote-tools", {
  transport: "http",
  url: "https://mcp.example.com/v1",
  headers: { Authorization: "Bearer token" },
  retries: 3,
  timeout: 15000,
});

Previous Updates (Q4 2025)

Image Generation – Generate images from text prompts using Gemini models via Vertex AI or Google AI Studio. → Guide
Gemini 3 Preview Support - Full support for gemini-3-flash-preview and gemini-3-pro-preview with extended thinking
Structured Output with Zod Schemas – Type-safe JSON generation with automatic validation. → Guide
CSV & PDF File Support – Attach CSV/PDF files to prompts with auto-detection. → CSV | PDF
LiteLLM & SageMaker – Access 100+ models via LiteLLM, deploy custom models on SageMaker. → LiteLLM | SageMaker
OpenRouter Integration – Access 300+ models through a single unified API. → Guide
HITL & Guardrails – Human-in-the-loop approval workflows and content filtering middleware. → HITL | Guardrails
Redis & Context Management – Session export, conversation history, and automatic summarization. → History

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

Get Started in Two Steps

# 1. Run the interactive setup wizard (select providers, validate keys)
pnpm dlx @juspay/neurolink setup

# 2. Start generating with automatic provider selection
npx @juspay/neurolink generate "Write a launch plan for multimodal chat"

Need a persistent workspace? Launch loop mode with npx @juspay/neurolink loop - Learn more →

🌟 Complete Feature Set

NeuroLink is a comprehensive AI development platform. Every feature below is available today and fully documented.

🤖 AI Provider Integration

Provider neurons behind 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.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

This table highlights the most commonly used providers. NeuroLink also ships DeepSeek, NVIDIA NIM, LM Studio, llama.cpp, xAI, Groq, Cerebras, SambaNova, Together AI, Fireworks, Perplexity, Cloudflare, Cohere, Voyage AI, Jina AI, Stability AI, Ideogram, Recraft, Replicate, plus TypeSafe Jev and Laya (the two decide()-only providers for typed, calibrated decisions) and the full voice/media roster — see the Provider Guides index for the full roster.

📖 Provider Comparison Guide - Detailed feature matrix and selection criteria 🔬 Provider Feature Compatibility - Test-based compatibility reference for 19 features (dated snapshot covering a subset of the full provider list)

🔧 Built-in Tools & MCP Integration

6 Core Tools (work across supported 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

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

📁 Multimodal & File Processing

17 file processors across 6 categories (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 - Processors work across supported 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
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 — that certification is your infrastructure's, not NeuroLink's
✅ 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 5-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,
    store: "redis", // Automatically uses REDIS_URL
    ttl: 86400, // 24-hour session expiration
  },
});

// Or explicit configuration
const neurolinkExplicit = new NeuroLink({
  conversationMemory: {
    enabled: true,
    store: "redis",
    redis: {
      host: "redis.example.com",
      port: 6379,
      password: process.env.REDIS_PASSWORD,
      tls: true, // Enable for production
    },
  },
});

// Export conversation for analytics
const history = await neurolink.exportConversation({ format: "json" });
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

34 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

📖 Complete CLI Reference - All commands and options

🤖 GitHub Action

Run AI-powered workflows directly in GitHub Actions with broad 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	Broad provider support behind one 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

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

const neurolink = new NeuroLink({
  conversationMemory: {
    enabled: true,
    store: "redis",
  },
  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);

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",
  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	Provider neurons behind one API, 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) + STT (4 providers) + realtime 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, 5-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`
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 - 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 deployment setup
Redis Migration - Migration patterns

Migration Guides:

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

Developer Experience:

Cookbook - 15 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
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.

🧠 NeuroLink

🧠 What is NeuroLink?​

What's New (Q1 2026)​

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

Get Started in Two Steps​

🌟 Complete Feature Set​

🤖 AI Provider Integration​

🔧 Built-in Tools & MCP Integration​

💻 Developer Experience Features​

📁 Multimodal & File Processing​

🏢 Enterprise & Production Features​

Enterprise Persistence: Redis Memory​

Capabilities​

Quick Setup​

Docker Quick Start​

🎨 Professional CLI​

🤖 GitHub Action​

💰 Smart Model Selection​

Cost Optimization Features​

Revolutionary Interactive CLI​

Why Interactive Mode Changes Everything​

Live Demo: Development Session​

Session Commands Reference​

CLI & SDK Essentials​

Gemini 3 with Extended Thinking​

Platform Capabilities at a Glance​

Documentation Map​

New in 2026: Enhanced Documentation​

Integrations​

Contributing & Support​