Skip to Content

CTRL K

• Getting Started
• Meet Neo
• Quick Start
• Core Concepts
• VS Code Extension
• Cursor IDE
• Neo MCP
• Neo for Claude Code
• Bring Your Own LLM Keys
• Learn More
• Projects
  • Production-Ready A/B/n Testing Framework
  • Adversarial Robustness Probe: Stress-Testing NLP and Vision Models
  • Natural Language Time Series Forecasting with TimesFM
  • Multilingual ASR Pipeline with Qwen3-ASR-0.6B
  • Attention Head Visualiser: Mapping GPT-2 Heads
  • AutoDoc: Autonomous Documentation Agent
  • AutoPrompter: Closed-Loop Prompt Optimization
  • Carbon-Aware Model Training Pipeline
  • Code Agent Analysis and Refactoring Tool
  • Low-Latency CPU-Based Voice Assistant with Streaming TTS
  • Embedding Evaluator: Vector Quality & Drift Audits
  • GitHub Repo Query Agent
  • GPU Scout: Cloud GPU Monitoring & Spot Alerts
  • Hallucination Benchmark Tool
  • Helix: Self-Healing CI/CD Agent
  • Medical Report Analysis (HIPAA)
  • How to Fine-Tune an LLM Using NEO
  • Hypothesis Engine: Autonomous Research Framework
  • Invoice OCR Pipeline
  • Latest LLMs: Real-Life Task Evaluation
  • LLM Consistency Monitor: Detect Prompt Brittleness
  • LLM Council: Multi-Model Deliberation
  • LLM Evaluator Tool
  • LLM Response Judge: Auto-Grade AI Responses
  • MCP Optimization & Suggestion Agent
  • Multi-Agent Memory Management System
  • Multi-Agent Observability Platform
  • Multi-Model RAG System
  • Multi-Query Batch Inference Optimization
  • NeuroLens: Concept Neuron Discovery
  • Orbit: 3D Dependency Visualiser
  • Prompt A/B Testing Tool: Statistical LLM Evaluation
  • Prompt Injection Defence System
  • Quantization-Aware Training for Edge Deployment
  • Real-Time Voice Translation
  • Spec to Ship: Multi-Agent Feature Delivery
  • Stock Trading Agent Swarm
  • Table Extraction from Financial Documents
• Platform Features
• Use Cases
• FAQ
• Resources
• Dashboard ↗
• Datasets
• Settings

Light

Neo MCP

Use the Model Context Protocol (MCP) to wire your editor to Neo: the neo-mcp package runs the server locally and syncs results into your project folder.

Get your API key

1. Open API keys in the Neo dashboard (sign in if prompted).
2. Create a key and copy it. Keys look like sk-v1-… — treat them like secrets and do not commit them to git.

You will paste this value wherever the examples use sk-v1-YOUR_KEY.

Install

Python 3.11+:

pip install neo-mcp

LinuxWindows

If pip install neo-mcp fails with error: externally-managed-environment, run:

python3 -m pip install --user --break-system-packages neo-mcp

Installs to ~/.local/ without sudo.

Editor configuration

Replace sk-v1-YOUR_KEY with your real key in the snippet for your editor.

Claude CodeCursorWindsurfVS CodeZedContinueCodex CLIAntigravity

Claude Code configures MCP through the claude mcp CLI (run these in your system terminal, not inside a chat).

1. Register Neo

claude mcp add --scope user neo \
  -e NEO_SECRET_KEY=sk-v1-YOUR_KEY \
  -- python3 -m neo_mcp

2. Confirm it’s connected

claude mcp list

You should see neo with a green checkmark.

Demo: Run a task through MCP

MCP tools

Tool	What it does
neo_submit_task	Start a Neo task; returns a thread_id. Optional wait_for_completion blocks until finished.
neo_task_status	Poll status (RUNNING, COMPLETED, WAITING_FOR_FEEDBACK, etc.).
neo_get_messages	Read the task transcript after completion (large output may be capped).
neo_list_tasks	List recent or active tasks (e.g. after reopening the editor).
neo_send_feedback	Reply when Neo is waiting for input (WAITING_FOR_FEEDBACK).
neo_pause_task / neo_resume_task	Pause or resume a task.
neo_stop_task	Stop and tear down a task.
neo_add_integration	Store a provider key (GitHub, HuggingFace, Anthropic, OpenRouter, or any custom secret) on your machine so Neo can use it in tasks.
neo_list_integrations	List configured integrations (provider names only — never prints the secret).
neo_test_integration	Call the provider’s API once to confirm the stored key is still valid.
neo_remove_integration	Delete a stored key and its file (or keyring entry).

Typical flow: submit → poll status until COMPLETED or feedback → get messages (or use wait_for_completion on submit to skip polling).

Integrations

Give Neo access to external services — GitHub, HuggingFace, Anthropic, OpenRouter, or any custom secret — by storing API keys on your machine once. Neo injects them as environment variables every time it runs a task, so your scripts, CLIs, and libraries just work. Keys never leave your machine.

Adding a key

Just tell Neo in plain English — from any MCP-connected editor:

“Add my Anthropic key sk-ant-... to Neo.”

“Store my GitHub PAT ghp... so Neo can push to my repos.”

“Save my HuggingFace token hf... for downloading models.”

Neo calls neo_add_integration behind the scenes. You only need to do this once per provider — the key is stored locally and reused across every future task.

Provider	Credential	What Neo can do with it
github	Personal Access Token (ghp_...)	Clone private repos, push, open PRs
huggingface	Token (hf_...)	Download private models and datasets
anthropic	API key (sk-ant-...)	Run Claude models inside your tasks
openrouter	API key (sk-or-...)	Route through any model OpenRouter supports

You can also store any custom secret the same way — use any provider name and Neo will save it and expose it to tasks.

Where keys are stored

File on disk (default)OS keyring (safer)

Keys are saved to a small file on your machine at ~/.neo/integrations/<provider>.env. The file is owner-read-only — no other user on your computer can access it. This is the same way tools like gh, aws, and huggingface-cli store their tokens.

For GitHub and HuggingFace, Neo also writes the token where the official CLI expects it (~/.git-credentials and ~/.cache/huggingface/token), so commands like git clone and huggingface-cli just work on their own — without Neo running.

• Works everywhere: Mac, Linux, Docker, servers, CI.
• Nothing extra to install.

Tip: turn on full-disk encryption (FileVault on macOS, BitLocker on Windows, LUKS on Linux) for an extra layer of protection when your machine is powered off or stolen.

How Neo uses your keys

When Neo runs a task, it reads your configured keys and sets them as environment variables on each child process:

Variable	Provider
ANTHROPIC_API_KEY	anthropic
OPENROUTER_API_KEY	openrouter
HF_TOKEN / HUGGING_FACE_HUB_TOKEN	huggingface
GITHUB_TOKEN / GH_TOKEN	github

Any script, CLI, or library that reads these env vars works out of the box — no per-task configuration needed.

Managing integrations

neo_list_integrations              # shows configured providers (names only, never the key)
neo_test_integration anthropic     # calls the provider's API to confirm the key is valid
neo_remove_integration anthropic   # deletes the stored key and its file or keyring entry

Security

• Keys never leave your machine — they are never sent to the Neo backend, written to logs, or committed to git.
• ~/.neo/ and .env files are already in .gitignore.
• Secret files are always mode 0o600.
• neo_list_integrations returns provider names only, never the secret itself.
• Use keys with the smallest scope you can, and rotate them if you suspect anything went wrong.

---