Local AI server with persistent memory. Zero cloud. Full control.

I've reached the minimum viable product for the real world — but feedback is still missing. 🚀

Documentation · Install · Architecture · Releases

Català · Español

• The Story
• Screenshots
• Why Server Nexe?
• Quick Start
  • Option A: DMG Installer (macOS)
  • Option B: Command Line
  • Option C: Headless (servers, scripts, CI)
• Backends
• Available Models by RAM Tier
• Architecture
  • Request processing pipeline
• Plugin System
• AI-Ready Documentation
• Security
• Platform Support
• Requirements
• Testing
• Roadmap
• Limitations
• Contributing
• Acknowledgments
• Disclaimer

Server Nexe started as a learning-by-doing experiment: "What would it take to have your own local AI with persistent memory?" Since I wasn't going to build an LLM, I started picking up pieces to assemble a useful lego for myself and my day-to-day work. One thing led to another — inference backends, RAG pipelines, vector search, plugin systems, security layers, a web UI, an installer with hardware detection.

This entire project — code, tests, audits, documentation — has been built by one person orchestrating different AI models, both local (MLX, Ollama) and cloud (Claude, GPT, Gemini, DeepSeek, Qwen, Grok...), as collaborators. The human decides what to build, designs the architecture, reviews lines and runs tests. The AIs write, audit, and stress-test under human direction.

What began as a prototype has turned into a genuinely useful product: 4842 tests, security audits, encryption at rest, a macOS installer with hardware detection, and a plugin system. It's not done — there's a roadmap full of ideas — but it already does what it set out to do: run an AI server on your machine, with memory that persists, and zero data leaving your device.

This is not trying to compete with ChatGPT or Claude. But it can be complementary for less demanding tasks. It's an open-source tool for people who want to own their AI infrastructure. Built by one person in Barcelona, with AI as co-pilot, music, and stubbornness.

More technically: what was a giant spaghetti monster ended up distilling, refactor after refactor, into a minimal, agnostic, modular core — where security and memory are solved at the base so building on top is fast and comfortable, in human–AI collaboration. Whether that worked is for the community to say (the AI says yes, but what did you expect 🤪).

Web UI — light mode	Web UI — dark mode
System tray menu (NexeTray.app)	SwiftUI installer wizard (DMG)

Your conversations, documents, embeddings, and model weights stay on your machine. Always. Server Nexe combines LLM inference with a persistent RAG memory system — your AI remembers context across sessions, indexes your documents, and never phones home.

Download the latest Install Nexe.dmg from Releases. The wizard handles everything: hardware detection, backend selection, model download, and configuration.

git clone https://github.com/jgoy-labs/server-nexe.git
cd server-nexe
./setup.sh      # guided installation (detects hardware, picks backend & model)
nexe go         # start server on port 9119

Once running:

nexe chat               # interactive chat
nexe chat --rag         # chat with RAG memory
nexe memory store "Barcelona is the capital of Catalonia"
nexe memory recall "capital Catalonia"
nexe status             # system status

python -m installer.install_headless --backend ollama --model qwen3.5:latest
nexe go

Endpoints at http://localhost:9119:

Authentication via X-API-Key header. Key is generated during installation and stored in .env.

The installer auto-detects your hardware and recommends the best backend. You can switch anytime in personality/server.toml.

The installer organizes the 16 catalog models by the RAM available on your machine (4 tiers):

In addition, you can use any Ollama model by name or any GGUF model from Hugging Face.

server-nexe/
├── core/                 # FastAPI server, endpoints, CLI, config, metrics, resilience
│   ├── endpoints/        # REST API (v1 chat, health, status, system)
│   ├── cli/              # CLI commands & i18n (ca/es/en)
│   └── resilience/       # Circuit breaker, rate limiting
├── personality/          # Module manager, plugin discovery, server.toml
│   ├── loading/          # Plugin loading pipeline (find, validate, import, lifecycle)
│   └── module_manager/   # Discovery, registry, config, sync
├── memory/               # Embeddings, RAG engine, vector memory, document ingestion
│   ├── embeddings/       # Chunking, embedding generation
│   ├── rag/              # Retrieval-augmented generation pipeline
│   └── memory/           # Persistent vector store (Qdrant)
├── plugins/              # Auto-discovered plugin modules
│   ├── mlx_module/       # MLX backend (Apple Silicon)
│   ├── llama_cpp_module/ # llama.cpp backend (GGUF)
│   ├── ollama_module/    # Ollama bridge
│   ├── security/         # Auth, injection detection, CSRF, rate limiting, input sanitization
│   └── web_ui_module/    # Browser-based chat UI with file upload
├── installer/            # Guided installer, headless mode, hardware detection, model catalog
├── knowledge/            # Indexed documentation for RAG (ca/es/en)
└── tests/                # Integration & e2e test suites

flowchart LR
    A[Request] --> B[Auth<br/>X-API-Key]
    B --> C[Rate Limit<br/>slowapi]
    C --> D[validate_string_input<br/>context parameter]
    D --> E[RAG Recall<br/>3 collections]
    E --> F[_sanitize_rag_context<br/>injection filter]
    F --> G[LLM Inference<br/>MLX/Ollama/llama.cpp]
    G --> H[Stream Response<br/>SSE markers]
    H --> I[MEM_SAVE Parsing<br/>fact extraction]
    I --> J[Response<br/>to client]

Server Nexe uses a duck typing protocol (NexeModule Protocol) — no class inheritance, no BasePlugin. Each plugin is a directory under plugins/ with a manifest.toml and a module.py.

5 active plugins:

The knowledge/ folder contains 13 thematic documents × 3 languages = 39 files, structured with YAML frontmatter for RAG ingestion:

API, Architecture, Use Cases, Errors, Identity, Installation, Limitations, Plugins, RAG, README, Security, Testing, Usage.

Point any AI assistant at this repo and it can understand the complete architecture.

Server Nexe includes a security module enabled by default:

• API key authentication on all endpoints
• CSP headers (script-src 'self', no unsafe-inline)
• CSRF protection with token validation
• Rate limiting per IP
• Input sanitization — 6 injection detectors + Unicode normalization
• Jailbreak detection — 47 pattern speed-bump detector
• Upload denylist — blocks accidental upload of API keys, PEM keys
• Memory injection protection — tag stripping on all input paths
• RAG injection sanitization — [MEM_SAVE:], [MEM_DELETE:], [OLVIDA|OBLIT|FORGET:], [MEMORIA:] neutralized at ingest and retrieval (v0.9.9)
• Pipeline enforcement — all chat through canonical endpoints only
• Encryption at rest — AES-256-GCM, SQLCipher, auto default, fail-closed (v0.9.2+)
• Trusted host middleware

Note: This project has not been tested in production with real users. Security testing has been performed by AI, not by professional auditors. See SECURITY.md for full disclosure and vulnerability reporting.

Since v0.9.9, server-nexe requires macOS 14 Sonoma+ with Apple Silicon (M1 or later). The pre-built wheels in the DMG are arm64 exclusive. Linux with the llama.cpp and Ollama backends should work, but the full compatibility audit is on the roadmap.

Intel Macs and macOS 13 Ventura are no longer supported. Apple Silicon only (arm64). Linux: Works with llama.cpp and Ollama backends. Full Linux compatibility audit is on the roadmap.

4842 tests collected (of 4990 total, 148 deselected by default markers) with ~85% code coverage. CI runs the full suite on every push.

# Unit tests
pytest core memory personality plugins -m "not integration and not e2e and not slow" \
  --cov=core --cov=memory --cov=personality --cov=plugins \
  --cov-report=term --tb=short -q

# Integration tests (requires Ollama running)
NEXE_AUTOSTART_OLLAMA=true pytest -m "integration" -q

Server Nexe is actively developed. Here's what's coming:

• Persistent memory with RAG (v0.9.0)
• Encryption at rest — AES-256-GCM (v0.9.0)
• macOS code signing & notarization (v0.9.0)
• Security hardening — jailbreak detection, upload denylist, pipeline enforcement (v0.9.1)
• Encryption default auto, fail-closed (v0.9.2)
• Embeddings on ONNX (fastembed), PyTorch removed (v0.9.3)
• Multimodal VLM — 4 backends (Ollama, MLX, llama.cpp, Web UI) (v0.9.7)
• Precomputed KB embeddings (~10.7x faster startup) (v0.9.8)
• RAG injection sanitization (MEM tags neutralized at ingest and retrieval) (v0.9.9)
• Offline install bundle — all wheels + embedding model in DMG (~1.2 GB, post-v0.9.9)
• Thinking toggle endpoint — PATCH /session/{id}/thinking (post-v0.9.9)
• Native macOS app (SwiftUI, replaces Python tray)
• Configurable inference parameters via UI
• Community forum

See CHANGELOG.md for version history.

Honest disclosure of what server Nexe does not do or does not do well:

• Local models < cloud — Local models are less capable than GPT-4 or Claude. That's the trade-off for privacy.
• RAG is not perfect — Homonymy, negations, cold start (empty memory), and contradictory information across time periods.
• Partially OpenAI-compatible API — /v1/chat/completions works. Missing: /v1/embeddings, /v1/models, function calling, and multimodal.
• Single user — Mono-user by design. No multi-device sync, no accounts.
• No fine-tuning — You cannot train or fine-tune models.
• New encryption — Added in v0.9.0 (default auto since v0.9.2, fail-closed). Not battle-tested. If you lose the master key, data cannot be recovered (see MEK fallback: file → keyring → env → generate).
• Single developer, single real user — Personal open-source project, not an enterprise product.

See knowledge/en/LIMITATIONS.md for full detail.

See CONTRIBUTING.md for setup instructions and guidelines.

server-nexe is built on the shoulders of these amazing open-source projects:

AI & Inference

• MLX — Apple Silicon native ML framework
• llama.cpp — Efficient GGUF model inference
• Ollama — Local model management and serving
• fastembed — ONNX-based text embeddings (replaced sentence-transformers since v0.9.3, saves ~600 MB)
• sentence-transformers — Historical: original embedding backend, replaced by fastembed in v0.9.3
• Hugging Face — Model hub and transformers library

Infrastructure

• Qdrant — Vector search engine powering RAG memory
• FastAPI — High-performance async web framework
• Uvicorn — Lightning-fast ASGI server
• Pydantic — Data validation

Tools & Libraries

• Rich — Beautiful terminal formatting
• marked.js — Markdown rendering in web UI
• PyPDF — PDF text extraction for RAG
• rumps — macOS menu bar integration

Security & Monitoring

• Prometheus — Metrics and monitoring
• SlowAPI — Rate limiting

Also built with: Python, NumPy, httpx, tenacity, Click, Typer, Colorama, python-dotenv, PyYAML, toml, structlog, starlette-csrf, python-multipart, psutil, PyObjC, and Linux.

20% of Enterprise sponsorships go directly to supporting these projects.

Built with AI collaboration · Barcelona

This software is provided "as is", without warranty of any kind. Use it at your own risk. The author is not responsible for any damage, data loss, security incidents, or misuse arising from the use of this software.

See LICENSE for details.

Version 1.0.2-beta · Apache 2.0 · Made by Jordi Goy in Barcelona