### Install Plugin Command

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/ROADMAP.md

Example command to install a plugin from the registry.

```bash
nmem plugin install sentiment-boost
```

--------------------------------

### Install and Start Neural Memory Server

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/brain-sharing.md

Install the server package and start the Neural Memory server. Ensure you have Python 3.11 or later.

```bash
pip install neural-memory[server]
nmem serve --host 0.0.0.0 --port 8000
```

--------------------------------

### Install and Serve Web UI

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/index.md

Install the neural-memory package with server support and start the serve command. The web UI can then be accessed at http://localhost:8000/ui.

```bash
pip install neural-memory[server]
nmem serve
# Open http://localhost:8000/ui
```

--------------------------------

### Setup Neural Memory Cloud Sync

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/FAQ.md

Perform a one-time setup for Neural Memory cloud sync by running the setup action. This will guide you through the registration process.

```python
# One-time setup
nmem_sync_config(action="setup")  # Shows registration steps
```

--------------------------------

### Install Dependencies and Start Dev Server

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/dashboard/README.md

Installs project dependencies and starts the Vite development server. The server proxies API requests to localhost:8000 and is accessible at http://localhost:5174.

```bash
npm install

npm run dev
# Opens at http://localhost:5174

# In another terminal, start the NeuralMemory server
nmem serve
```

--------------------------------

### Guided Setup for MCP Tools

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/cloud-sync.md

Run this command for a guided, step-by-step setup tailored to your current configuration when using Neural Memory as an MCP tool in Claude Code or Cursor.

```python
nmem_sync_config(action="setup")
```

--------------------------------

### Complete Python Example

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/api/python.md

Demonstrates the full lifecycle of using the neural-memory library, including setup, storing memories, querying, and applying decay.

```python
import asyncio
from neural_memory import Brain, BrainConfig
from neural_memory.storage import SQLiteStorage
from neural_memory.engine.encoder import MemoryEncoder
from neural_memory.engine.retrieval import ReflexPipeline, DepthLevel
from neural_memory.engine.lifecycle import DecayManager

async def main():
    # Setup
    storage = SQLiteStorage("./memories.db")
    await storage.initialize()

    brain = Brain.create("work", config=BrainConfig(
        max_context_tokens=2000
    ))
    await storage.save_brain(brain)
    storage.set_brain(brain.id)

    encoder = MemoryEncoder(storage, brain.config)
    pipeline = ReflexPipeline(storage, brain.config)

    # Store memories
    await encoder.encode("Met with team to discuss architecture")
    await encoder.encode("DECISION: Use microservices. REASON: Better scaling")
    await encoder.encode("TODO: Set up CI/CD pipeline")

    # Query
    result = await pipeline.query(
        "What architecture decision was made?",
        depth=DepthLevel.CONTEXT
    )
    print(f"Answer: {result.context}")

    # Apply decay (for old memories)
    decay_manager = DecayManager()
    report = await decay_manager.apply_decay(storage, dry_run=True)
    print(f"Would decay {report.neurons_decayed} neurons")

asyncio.run(main())
```

--------------------------------

### Reproduce Benchmark Script

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/benchmarks.md

Instructions to reproduce the benchmark, including necessary package installations and environment variable setup.

```bash
pip install cognee neural-memory
DASHSCOPE_API_KEY=your-key python scripts/benchmark_cognee_vs_nm.py
```

--------------------------------

### Install NeuralMemory

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/landing/index.html

Install the NeuralMemory package using pip. This is the primary way to get started with the library.

```bash
$ pip install neural-memory
```

--------------------------------

### Start Neural Memory Web Visualization Server

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/quickstart.md

Install the server component and start the `nmem serve` command to launch a web visualization for your Neural Memory brain.

```bash
pip install neural-memory[server]
nmem serve
```

--------------------------------

### TOML Configuration Example

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/packaging-free-paid.md

Example of how the license key should be configured in the TOML configuration file.

```toml
[license]
key = "eyJhbGciOiJS..."
```

--------------------------------

### Install Neural Memory

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/blog/why-i-built-neuralmemory.md

Install the neural-memory package using pip. This is the primary way to get started with the library.

```bash
pip install neural-memory
```

--------------------------------

### Example Workflow with Neural Memory CLI

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/quickstart.md

A typical workflow demonstrating session start context retrieval, remembering during work, recalling information, and checking pending tasks.

```bash
# Start of session - get context
nmem context --limit 10

# During work - remember important things
nmem remember "UserService now uses async/await"
nmem remember "DECISION: Use JWT for auth. REASON: Stateless" --type decision
nmem todo "Add rate limiting to API" --priority 8

# When you need to recall
nmem recall "auth decision"
nmem recall "UserService changes"

# End of session - check what's pending
nmem list --type todo
```

--------------------------------

### GitHub Actions: Setup and Memory Integration

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/integration.md

This GitHub Actions workflow sets up Python, installs NeuralMemory, and remembers deployment and CI status.

```yaml
name: CI with Memory

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Setup Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'

      - name: Install NeuralMemory
        run: pip install neural-memory

      - name: Remember deployment
        if: github.ref == 'refs/heads/main'
        run: |
          nmem remember "Deployed ${{ github.sha }} to main" \
            --type workflow \
            --tag deploy

      - name: Remember test results
        if: always()
        run: |
          nmem remember "CI: ${{ job.status }} for ${{ github.sha }}" \
            --type workflow \
            --tag ci
```

--------------------------------

### Install and Run Chatbot Locally

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/docs-chatbot.md

Install the necessary packages and start the chatbot application. The default port is 7860, but a custom port can be specified.

```bash
pip install neural-memory gradio
python chatbot/app.py
```

--------------------------------

### Start Neural Memory API Server

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/quickstart-guide.md

Start the API server with auto-consolidation enabled by specifying a port.

```bash
nmem serve -p 8765    # Start API server with auto-consolidation
```

--------------------------------

### Install Hugging Face Hub and Login

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/docs-chatbot.md

Install the huggingface_hub library and log in to your Hugging Face account, which is a prerequisite for deploying to HuggingFace Spaces.

```bash
pip install huggingface_hub
huggingface-cli login
```

--------------------------------

### Start NeuralMemory Server

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/api/server.md

Start the NeuralMemory server using the command-line interface, specifying host and port.

```bash
nmem serve --host 0.0.0.0 --port 8000
```

--------------------------------

### Initialize NeuralMemory

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/cli-reference.md

Use `nmem init` to set up NeuralMemory. Options allow for overwriting existing configurations, skipping specific setup steps like MCP auto-configuration or skills installation, or enabling an interactive wizard.

```bash
nmem init [OPTIONS]
```

--------------------------------

### Benchmark Reproduce Command

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/benchmarks.md

Install necessary libraries and set your API key to reproduce the benchmark. This command installs Mem0 and sentence-transformers, then runs the benchmark script.

```bash
pip install mem0ai sentence-transformers
DASHSCOPE_API_KEY=your-key python scripts/benchmark_mem0_vs_nm.py
```

--------------------------------

### Installing Development Dependencies

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/architecture/scalability.md

Install the project with development dependencies using pip. This is a prerequisite for running benchmarks.

```bash
pip install -e ".[dev]"
```

--------------------------------

### Install uv and neural-memory with pipx

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/mcp-server.md

If 'uvx' is not found, first install 'uv' using pip, or alternatively, install neural-memory using pipx for isolated environments.

```bash
# Install uv first
pip install uv

# Or use pipx
pipx install neural-memory
```

--------------------------------

### Install and Build VS Code Extension

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/integration.md

Install dependencies and build the VS Code extension from the command line.

```bash
cd vscode-extension
npm install && npm run build
```

--------------------------------

### Install NeuralMemory with all extras

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/FAQ.md

Use this command to install the NeuralMemory package along with all optional dependencies, including server and NLP capabilities. This is useful for a full-featured installation.

```powershell
python -m pip install neural-memory[all]
```

--------------------------------

### Install NeuralMemory Packages

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/openclaw-plugin.md

Install the Python backend and the npm plugin package for NeuralMemory. Verify both installations using their respective CLI commands.

```bash
pip install neural-memory
npm install -g neuralmemory
```

```bash
nmem --help
nmem-mcp --help
```

--------------------------------

### Start FastAPI Server

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/cli.md

Use this command to start the main FastAPI server. You can specify the host and port to bind to, and enable auto-reloading for development.

```bash
nmem serve [OPTIONS]
```

--------------------------------

### Install Bundled Agent Skills

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/cli.md

Installs the pre-packaged agent skills into the default `~/.claude/skills/` directory. Use the `--force` option to overwrite existing skills or `--list` to see available skills without installing.

```bash
nmem install-skills [OPTIONS]
```

```bash
nmem install-skills
```

```bash
nmem install-skills --force
```

```bash
nmem install-skills --list
```

--------------------------------

### Initialize Neural Memory Basics

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/quickstart-guide.md

Run `nmem init` for basic setup. For advanced features like embeddings, run `nmem setup embeddings` separately.

```bash
nmem init
```

--------------------------------

### Install and Activate Neural Memory Pro

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/pro-quickstart.md

Install the neural-memory package and activate your Pro license using the provided key. This is the first step to using Pro features.

```bash
pip install neural-memory
nmem pro activate YOUR_LICENSE_KEY
```

--------------------------------

### Install Gemini Provider

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/embedding-setup.md

Install the neural-memory package with Gemini embedding support. Requires Google API key.

```bash
pip install neural-memory[embeddings-gemini]
```

--------------------------------

### Install and Activate Neural Memory Pro

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/landing/pro.md

Install the neural-memory package which includes Pro features. Activate Pro features using your license key.

```bash
pip install neural-memory              # Pro features included
nmem pro activate YOUR_LICENSE_KEY    # activate with your key
```

--------------------------------

### Development Installation of Neural Memory

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/installation.md

Set up Neural Memory for local development by cloning the repository, installing in editable mode, and setting up pre-commit hooks.

```bash
git clone https://github.com/nhadaututtheky/neural-memory
cd neural-memory
pip install -e ".[dev]"
pre-commit install
```

--------------------------------

### Install All Neural Memory Features

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/installation.md

Install Neural Memory with all available optional dependencies, including server and NLP features.

```bash
pip install neural-memory[all]
```

--------------------------------

### Install Pre-commit Hooks

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/CONTRIBUTING.md

Install pre-commit hooks to automatically check code style and quality before commits.

```bash
pre-commit install
```

--------------------------------

### Install NeuralMemory from source

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/FAQ.md

Install the NeuralMemory library in editable mode from a local clone of the repository. This allows for immediate reflection of code changes without reinstallation.

```bash
git clone https://github.com/nhadaututtheky/neural-memory.git
cd neural-memory
pip install -e ".[all,dev]"
```

--------------------------------

### Start Server with Uvicorn

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/api/server.md

Alternatively, start the NeuralMemory server directly using uvicorn for development, enabling hot-reloading.

```bash
uvicorn neural_memory.server:app --reload --port 8000
```

--------------------------------

### Install Neural Memory with Server Dependencies

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/installation.md

Install Neural Memory along with optional dependencies for the FastAPI REST API and Web UI.

```bash
pip install neural-memory[server]
```

--------------------------------

### Clone Repository and Install Dependencies

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/README.md

Clone the Neural Memory repository and install development dependencies. This is the initial step for setting up the project for development.

```bash
git clone https://github.com/nhadaututtheky/neural-memory
cd neural-memory && pip install -e ".[dev]"
```

--------------------------------

### Telegram Backup Configuration Example

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/cli.md

Provides examples for checking Telegram status, testing the bot, and backing up brains, including specifying a brain name.

```bash
nmem telegram status               # Check config
```

```bash
nmem telegram test                  # Verify bot works
```

```bash
nmem telegram backup                # Backup current brain
```

```bash
nmem telegram backup --brain work   # Backup specific brain
```

--------------------------------

### Install Neural Memory Pro

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/landing/pro-landing.html

Install the Pro version of neural-memory using pip. This command automatically registers the necessary components and makes new tools available.

```bash
pip install neural-memory-pro
```

--------------------------------

### Clone Repository and Set Up Development Environment

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/contributing.md

Clone the repository, create and activate a virtual environment, install development dependencies, and set up pre-commit hooks.

```bash
git clone https://github.com/nhadaututtheky/neural-memory
cd neural-memory

python -m venv .venv
source .venv/bin/activate  # or .venv\Scripts\activate on Windows

pip install -e ".[dev]"

pre-commit install
```

--------------------------------

### Remembering a Boundary Memory with a Domain

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/CHANGELOG.md

Example of how to create a boundary memory and associate it with a specific domain using the `nmem_remember` function. This adds a `domain:` tag automatically.

```Python
nmem_remember(content="...", type="boundary", domain="financial")
```

--------------------------------

### Verify Development Setup

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/CONTRIBUTING.md

Run diagnostic and testing commands to ensure the development environment is set up correctly.

```bash
nmem doctor --dev
pytest tests/ -v
mypy src/
ruff check src/ tests/
```

--------------------------------

### Get Graph Data Response

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/api/server.md

Example JSON response structure for the GET /api/graph endpoint, detailing neurons, synapses, fibers, and statistics.

```json
{
  "neurons": [
    {
      "id": "n1",
      "type": "entity",
      "content": "Alice",
      "metadata": {}
    }
  ],
  "synapses": [
    {
      "id": "s1",
      "source_id": "n1",
      "target_id": "n2",
      "type": "discussed",
      "weight": 0.8
    }
  ],
  "fibers": [
    {
      "id": "f1",
      "summary": "Meeting notes",
      "neuron_count": 5
    }
  ],
  "stats": {
    "neuron_count": 150,
    "synapse_count": 280,
    "fiber_count": 45
  }
}
```

--------------------------------

### Knowledge Base Training Document Extraction

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/CHANGELOG.md

This snippet demonstrates the capability to extract information from various document formats for knowledge base training. Ensure optional dependencies are installed for non-text formats.

```python
doc_extractor.py
```

--------------------------------

### Create and Associate Projects

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/api/python.md

Shows how to create a project with a name, description, and duration, and then associate a typed memory with that project. Assumes 'storage' is initialized.

```python
from neural_memory.core import Project

# Create project
project = Project.create(
    name="Q1 Sprint",
    description="First quarter sprint",
    duration_days=14,
    tags={"sprint", "q1"}
)
await storage.add_project(project)

# Associate memories
memory = TypedMemory.create(
    fiber_id="fiber-123",
    memory_type=MemoryType.TODO,
    project_id=project.id
)

# Query project memories
memories = await storage.get_project_memories(project.id)
```

--------------------------------

### Temporal Range Query Response

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/temporal-recipes.md

This is an example of the JSON response structure when querying for a temporal range. It includes the specified start and end times, a list of matching fibers with their IDs, summaries, and start times, and the total count of results.

```json
{
  "start": "2026-04-25T00:00:00",
  "end": "2026-05-02T00:00:00",
  "fibers": [
    { "id": "fbr_...", "summary": "...", "time_start": "..." }
  ],
  "count": 12
}
```

--------------------------------

### Create Project CLI Command

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/cli.md

Creates a new project with options for description, duration, tags, and priority.

```bash
nmem project create NAME [OPTIONS]
```

--------------------------------

### Verify Neural Memory Setup

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/quickstart-guide.md

Run `nmem doctor` to check if your Neural Memory installation is healthy. Use `--fix` to automatically remediate common issues.

```bash
nmem doctor
```

```bash
nmem doctor --fix
```

--------------------------------

### Setup Optional Components

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/cli-reference.md

Use `nmem setup` to configure optional components. You can specify a component name or use flags to generate rules for all supported IDEs or to force overwriting existing files.

```bash
nmem setup [OPTIONS]
```

--------------------------------

### Install NeuralMemory Node.js Package

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/integrations/neuralmemory/README.md

Install the NeuralMemory Node.js package globally using npm. This is an alternative installation method for the OpenClaw plugin.

```bash
npm install -g neuralmemory
```

--------------------------------

### Create and Activate Virtual Environment

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/CONTRIBUTING.md

Set up a Python virtual environment for project dependencies. Activate it using the appropriate command for your operating system.

```bash
python -m venv .venv

# Windows
.venv\Scripts\activate

# Linux/Mac
source .venv/bin/activate
```

--------------------------------

### Python Client Example

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/api/server.md

Demonstrates how to use the httpx library to interact with the Neural Memory server for creating a brain, encoding memory, and querying.

```python
import httpx

async def main():
    async with httpx.AsyncClient() as client:
        # Create brain
        response = await client.post(
            "http://localhost:8000/brain/create",
            json={"name": "my-brain"}
        )
        brain = response.json()

        # Encode memory
        response = await client.post(
            "http://localhost:8000/memory/encode",
            headers={"X-Brain-ID": brain["id"]},
            json={"content": "Important decision made"}
        )

        # Query
        response = await client.post(
            "http://localhost:8000/memory/query",
            headers={"X-Brain-ID": brain["id"]},
            json={"query": "What decision?", "depth": 1}
        )
        result = response.json()
        print(result["context"])
```

--------------------------------

### Install or Manage Git Hooks

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/cli-reference.md

Use `nmem hooks` to install or manage git hooks for automatic memory capture. The default action is 'install', and you can specify the path to the git repository.

```bash
nmem hooks [OPTIONS]
```

--------------------------------

### Install NeuralMemory Skills

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/cli-reference.md

Use `nmem install-skills` to install NeuralMemory skills to the ~/.claude/skills/ directory. Options include forcing an overwrite with the latest version or listing available skills without installing.

```bash
nmem install-skills [OPTIONS]
```

--------------------------------

### Install Neural Memory with User Permissions on Windows

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/installation.md

Address permission errors on Windows by installing Neural Memory with the --user flag to install packages in the user's home directory.

```bash
pip install --user neural-memory
```

--------------------------------

### Conventional Commit Message Examples

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/contributing.md

Examples of commit messages following the conventional commits specification.

```text
feat: add decay manager for memory lifecycle
fix: handle null values in query parser
docs: update API reference
test: add tests for spreading activation
refactor: simplify neuron state management
chore: update dependencies
```

--------------------------------

### Error Handling Example (Bad)

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/CONTRIBUTING.md

Shows an example of overly broad exception handling, which is not recommended.

```python
try:
    result = storage.get_neuron(neuron_id)
except:
    pass
```

--------------------------------

### Create a New Project

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/cli-reference.md

Use 'nmem project create' to initialize a new project. You can specify a name, description, duration, tags, priority, and output format.

```bash
nmem project create [OPTIONS]
```

--------------------------------

### Create a Neuron Instance

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/api/python.md

Demonstrates how to instantiate a Neuron object, specifying its ID, type, content, and associated metadata. Includes examples of NeuronType.

```python
from neural_memory import Neuron, NeuronType

neuron = Neuron(
    id="neuron-123",
    type=NeuronType.ENTITY,
    content="Alice",
    metadata={"role": "developer"}
)
```

--------------------------------

### Verify NeuralMemory Installation

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/integrations/neuralmemory/README.md

Verify the installation of the NeuralMemory command-line interface. This command checks if the nmem-mcp tool is accessible.

```bash
nmem-mcp --help
```

--------------------------------

### Install Neural Memory Plugin

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/promo/discord-anthropic.md

Use this command to quickly add the Neural Memory plugin from the marketplace.

```bash
/plugin marketplace add nhadaututtheky/neural-memory
```

--------------------------------

### Install Neural Memory

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/promo/reddit-localllama.md

Install the neural-memory package. Use the `[embeddings]` extra for local embeddings via Ollama.

```bash
pip install neural-memory

# With local embeddings via Ollama
pip install neural-memory[embeddings]
```

--------------------------------

### Run MCP Server

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/getting-started/cli-reference.md

Starts the Model Context Protocol (MCP) server.

```bash
nmem mcp [OPTIONS]
```

--------------------------------

### Install OpenRouter Provider

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/embedding-setup.md

Install the neural-memory package with OpenRouter embedding support. Requires an OpenRouter API key.

```bash
pip install neural-memory[embeddings-openrouter]
```

--------------------------------

### Install OpenAI Provider

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/embedding-setup.md

Install the neural-memory package with OpenAI embedding support. Requires an OpenAI API key.

```bash
pip install neural-memory[embeddings-openai]
```

--------------------------------

### Configure MCP Server (Entry Point)

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/integration.md

Configure the NeuralMemory MCP server using its entry point command in `~/.claude/mcp_servers.json`.

```json
{
  "neural-memory": {
    "command": "nmem-mcp"
  }
}
```

--------------------------------

### Memory Compression Example

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/concepts/how-it-works.md

Provides a simple example of how old memories can be summarized into a single, concise summary neuron.

```text
Original: [20 detailed neurons about Tuesday meeting]
Compressed: [1 summary neuron: "API design meeting with Alice"]
```

--------------------------------

### Importing Data from Multiple Sources

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/memory-layer-unification.md

This snippet demonstrates how to initialize storage and a brain, set up a sync engine, and iterate through different adapters to import data into the unified memory. Ensure adapters are correctly configured with necessary credentials or paths.

```python
storage = SQLiteStorage("unified.db")
brain = Brain.create(name="all-memory")
await storage.save_brain(brain)
storage.set_brain(brain.id)

engine = SyncEngine(storage, brain.config)

# Import from all sources
sources = [
    get_adapter("chromadb", path="/data/chroma"),
    get_adapter("mem0", api_key="...", user_id="user-1"),
    get_adapter("cognee", api_key="..."),
]

for adapter in sources:
    result, state = await engine.sync(adapter)
    print(f"{adapter.system_name}: {result.records_imported} imported")
```

--------------------------------

### Get Neurons Response

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/api/server.md

The response from the GET /memory/neurons endpoint, listing neurons with optional filtering by type and limit.

```json
{
  "neurons": [
    {
      "id": "neuron-123",
      "type": "entity",
      "content": "Alice",
      "metadata": {}
    }
  ],
  "total": 1
}
```

--------------------------------

### Check Pro Dependencies Installation

Source: https://github.com/nhadaututtheky/neural-memory/blob/main/docs/guides/pro-quickstart.md

Use this command to verify if the necessary dependencies for Neural Memory Pro are installed correctly.

```bash
# Check if Pro deps are installed
python -c "from neural_memory.pro import is_pro_deps_installed; print(is_pro_deps_installed())"
```