Which integrations are available for this server?

Provides persistent semantic memory for LLMs using Turso's native vector search to store and retrieve concepts with 256-dimensional embeddings.

How do I use Neural-Stimulus?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Neural-Stimulus get context from last session about neural networks" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Neural-Stimulus

by recla93

Overview Schema Related Servers Score Discussions

Python

Local

Neural-Stimulus v3.1 — Turso Native Vector Search

Memoria semantica persistente per LLM con Turso vector search nativo (vector_distance_cos) e embedding 256-dim (feature hashing).

Costruisce un grafo di concetti attraverso le conversazioni: ogni scambio lascia keyword e link tipizzati (causa-effetto, analogia, evoluzione...) che si accumulano tra sessioni. In piu, ogni keyword ha un vettore 256-dim che permette la ricerca semantica per similarita.

Indice

Related MCP server: Memory MCP

Cosa fa

Neural-Stimulus e un server MCP (Model Context Protocol) che fornisce strumenti all'LLM per salvare, collegare e ritrovare concetti attraverso le conversazioni.

Scenario	Comportamento
Prima sessione	Grafo vuoto. L'LLM crea i primi nodi chiamando `ns_store_turn`.
Sessione successiva	L'LLM chiama `ns_status` + `ns_get_context` per riprendere da dove aveva lasciato.
Durante la chat	Ogni 3-5 turni, l'LLM salva nuovi concetti e link.
Ricerca esplorativa	L'LLM usa `ns_vector_search` per trovare concetti vicini per similarita semantica.

Importante: l'MCP server non chiama LLM. E solo storage + query. L'LLM decide cosa salvare e cosa linkare.

Architettura

TUO CLIENT MCP (OpenCode, Claude Desktop, Cursor, ecc.)
    │  chiama tool MCP (stdin/stdout)
    ▼
┌──────────────────────────────────────────────────┐
│  mcp_server.py  (Python)                         │
│  ├─ 12 tool MCP                                  │
│  ├─ embedding vettoriale 256-dim (feature hash)  │
│  └─ ricerca: Turso vector_distance_cos() o Python│
└─────────────────┬────────────────────────────────┘
                   ▼
┌──────────────────────────────────────────────────┐
│  Turso Database (pyturso) — vector search nativo │
│  ├─ graph.db (nodi, link, embedding BLOB)        │
│  ├─ vector_distance_cos(embedding, query)         │
│  │  (similarita calcolata internamente da Turso)  │
│  └─ fallback Python se Turso non disponibile      │
└──────────────────────────────────────────────────┘

Installazione

Windows (automatico)

Apri PowerShell (non ISE, non cmd) e incolla:

# 1. Scarica o copia la cartella Neural-Stimulus-hub-vector sul Desktop

# 2. Lancia l'installer (tutto automatico)
.\install.ps1

L'installer fa tutto da solo:

Passaggio	Cosa succede
Python	Verifica che Python >= 3.10 sia installato
Rust	Se `rustc` non esiste, scarica `rustup-init.exe` e installa il compilatore Rust
Linker	Se il linker MSVC (`link.exe`) non e presente, passa automaticamente alla toolchain GNU (MinGW)
Virtual env	Crea `.venv` in `%LOCALAPPDATA%\Programs\neural-stimulus-vector\`
pyturso	Compila il Turso Database engine da source Rust (~10-30 min la prima volta)
MCP SDK	Installa `mcp>=1.28.0`
Fastembed	Chiede se installare `fastembed` per embedding semantico 384-dim (opzionale, ~200MB). Se salta, resta feature hashing 256-dim
Fallback	Se pyturso non compila (es. senza Rust), installa solo MCP SDK — embedding vettoriali funzionano comunque con SQLite standard
Copia file	Copia tutti i file del progetto
Registrazione MCP	Aggiunge `neural-stimulus-vector` al tuo `opencode.json`
Start Menu	Crea shortcut in Start Menu > Neural-Stimulus
Verifica finale	Testa `import turso` e mostra il motore database attivo

Dopo l'installazione:

# 3. Riavvia OpenCode (o /reload)
# 4. L'LLM avra' a disposizione 12 tool MCP

Linux / macOS (manuale)

# 1. Clona
git clone https://github.com/<tuo-utente>/Neural-Stimulus-hub-vector.git
cd Neural-Stimulus-hub-vector

# 2. Crea virtual env
python3 -m venv .venv
source .venv/bin/activate

# 3. Installa dipendenze
pip install mcp pyturso

# (Opzionale) Embedding semantico invece di feature hashing
pip install fastembed                     # ~200MB, ONNX locale, 384-dim

# Nota: pyturso fornisce wheel precompilate per Linux/macOS
# (nessun bisogno di Rust toolchain)

# 4. Avvia il server MCP
python mcp_server.py

# 5. Configura il tuo client MCP (vedi sotto)

Docker

# Build dell'immagine (include Rust + pyturso precompilato)
docker build -t neural-stimulus-vector .

# Avvia container con volume persistente
docker run -v "$(pwd)/data:/data" -e NS_DB_PATH=/data/graph.db neural-stimulus-vector

# Per embedding semantico, aggiungi fastembed al Dockerfile:
#   RUN pip install fastembed

Configurazione per ogni client MCP

Neural-Stimulus funziona con qualsiasi client che implementa il protocollo MCP (Model Context Protocol). Ecco come configurarlo per ogni client.

OpenCode

Config: ~/.config/opencode/opencode.json

{
  "mcp": {
    "neural-stimulus": {
      "command": ["cmd", "/c", "%LOCALAPPDATA%\\Programs\\neural-stimulus-vector\\run_mcp.bat"],
      "type": "local"
    }
  },
  "instructions": [
    "path/to/AGENTS.md",
    "path/to/auto-context.md"
  ]
}

Su Linux/macOS:

{
  "mcp": {
    "neural-stimulus": {
      "command": ["python3", "/path/to/mcp_server.py"],
      "type": "local"
    }
  }
}

Claude Code

CLI (consigliato):

# Aggiunge il server al progetto corrente
claude mcp add neural-stimulus -- python3 /path/to/mcp_server.py

# Su Windows
claude mcp add neural-stimulus -- cmd /c "%LOCALAPPDATA%\Programs\neural-stimulus-vector\run_mcp.bat"

O manualmente — crea .mcp.json nella root del progetto:

{
  "mcpServers": {
    "neural-stimulus": {
      "command": "python3",
      "args": ["/path/to/mcp_server.py"]
    }
  }
}

Su Windows:

{
  "mcpServers": {
    "neural-stimulus": {
      "command": "cmd",
      "args": ["/c", "%LOCALAPPDATA%\\Programs\\neural-stimulus-vector\\run_mcp.bat"]
    }
  }
}

Scope: .mcp.json (progetto, condiviso via git) oppure ~/.claude.json (utente, tutti i progetti).

Claude Desktop

Config: claude_desktop_config.json

{
  "mcpServers": {
    "neural-stimulus": {
      "command": "cmd",
      "args": ["/c", "%LOCALAPPDATA%\\Programs\\neural-stimulus-vector\\run_mcp.bat"]
    }
  }
}

Su macOS:

{
  "mcpServers": {
    "neural-stimulus": {
      "command": "python3",
      "args": ["/path/to/mcp_server.py"]
    }
  }
}

Cursor

Config: ~/.cursor/mcp.json (globale) o .cursor/mcp.json (per progetto)

{
  "mcpServers": {
    "neural-stimulus": {
      "command": "python3",
      "args": ["/path/to/mcp_server.py"]
    }
  }
}

Su Windows:

{
  "mcpServers": {
    "neural-stimulus": {
      "command": "cmd",
      "args": ["/c", "%LOCALAPPDATA%\\Programs\\neural-stimulus-vector\\run_mcp.bat"]
    }
  }
}

Nota: Dopo aver modificato il config, chiudi e riapri Cursor — i server MCP si caricano solo all'avvio.

Windsurf

Config: ~/.codeium/windsurf/mcp_config.json (solo globale)

{
  "mcpServers": {
    "neural-stimulus": {
      "command": "python3",
      "args": ["/path/to/mcp_server.py"]
    }
  }
}

Attenzione: Windsurf usa command/args (non serverUrl) per server locali stdio. Se copi da Cursor, ricordati di cambiare url in serverUrl per server remoti, ma per server locali la sintassi e identica.

Gemini CLI (Google Antigravity)

Config: ~/.gemini/config/mcp_config.json

{
  "mcpServers": {
    "neural-stimulus": {
      "command": "python3",
      "args": ["/path/to/mcp_server.py"]
    }
  }
}

In alternativa, via CLI:

gemini config mcp add neural-stimulus --transport stdio -- python3 /path/to/mcp_server.py

OpenAI Codex / ChatGPT

OpenAI Codex supporta MCP nativamente. Configura il server nel file di settings del tuo progetto:

{
  "mcpServers": {
    "neural-stimulus": {
      "command": "python3",
      "args": ["/path/to/mcp_server.py"]
    }
  }
}

Per ChatGPT, i server MCP sono esposti tramite Connectors. Al momento non e possibile configurare server stdio arbitrari — solo server remoti HTTP approvati.

VS Code (GitHub Copilot)

Config: Via UI o file .vscode/settings.json

{
  "github.copilot.mcpServers": {
    "neural-stimulus": {
      "command": "python3",
      "args": ["/path/to/mcp_server.py"]
    }
  }
}

Zed

Config: ~/.config/zed/settings.json

{
  "mcp_servers": {
    "neural-stimulus": {
      "command": "python3",
      "args": ["/path/to/mcp_server.py"]
    }
  }
}

Su Windows:

{
  "mcp_servers": {
    "neural-stimulus": {
      "command": "cmd",
      "args": ["/c", "%LOCALAPPDATA%\\Programs\\neural-stimulus-vector\\run_mcp.bat"]
    }
  }
}

Nota: In Zed la chiave si scrive mcp_servers (underscore, non camelCase). I server MCP partono all'apertura del progetto.

Continue.dev

Config: ~/.continue/config.json

{
  "experimental": {
    "mcpServers": {
      "neural-stimulus": {
        "command": "python3",
        "args": ["/path/to/mcp_server.py"]
      }
    }
  }
}

Su Windows:

{
  "experimental": {
    "mcpServers": {
      "neural-stimulus": {
        "command": "cmd",
        "args": ["/c", "%LOCALAPPDATA%\\Programs\\neural-stimulus-vector\\run_mcp.bat"]
      }
    }
  }
}

Nota: Continue.dev richiede di abilitare experimental.mcpServers e di riavviare VS Code.

Cody (Sourcegraph)

Config: ~/.cody/mcp.json (globale) o .cody/mcp.json (progetto)

{
  "mcpServers": {
    "neural-stimulus": {
      "command": "python3",
      "args": ["/path/to/mcp_server.py"]
    }
  }
}

Su Windows:

{
  "mcpServers": {
    "neural-stimulus": {
      "command": "cmd",
      "args": ["/c", "%LOCALAPPDATA%\\Programs\\neural-stimulus-vector\\run_mcp.bat"]
    }
  }
}

Nota: Cody carica i server MCP all'avvio — riavvia l'estensione / IDE dopo aver modificato il config.

Amazon Q Developer

Config: ~/.aws/amazon-q/mcp.json

{
  "mcpServers": {
    "neural-stimulus": {
      "command": "python3",
      "args": ["/path/to/mcp_server.py"]
    }
  }
}

Su Windows:

{
  "mcpServers": {
    "neural-stimulus": {
      "command": "cmd",
      "args": ["/c", "%LOCALAPPDATA%\\Programs\\neural-stimulus-vector\\run_mcp.bat"]
    }
  }
}

Nota: Verifica che amazon-q sia aggiornato — il supporto MCP e stato aggiunto nella v1.4+.

Riepilogo configurazioni

Client	File config	Chiave server	Riavvio necessario
OpenCode	`~/.config/opencode/opencode.json`	`mcp`	`/mcp reload`
Claude Code	`.mcp.json` o `~/.claude.json`	`mcpServers`	`/mcp` o restart
Claude Desktop	`claude_desktop_config.json`	`mcpServers`	Riavvio app
Cursor	`~/.cursor/mcp.json`	`mcpServers`	Riavvio app
Windsurf	`~/.codeium/windsurf/mcp_config.json`	`mcpServers`	Riavvio app
Gemini CLI	`~/.gemini/config/mcp_config.json`	`mcpServers`	Riavvio CLI
OpenAI Codex	settings progetto	`mcpServers`	Riavvio
VS Code	`.vscode/settings.json`	`github.copilot.mcpServers`	Riavvio
Zed	`~/.config/zed/settings.json`	`mcp_servers`	Riavvio progetto
Continue.dev	`~/.continue/config.json`	`experimental.mcpServers`	Riavvio IDE
Cody (Sourcegraph)	`~/.cody/mcp.json`	`mcpServers`	Riavvio IDE
Amazon Q Developer	`~/.aws/amazon-q/mcp.json`	`mcpServers`	Riavvio IDE

Tool MCP disponibili

Tool	Descrizione
`ns_status`	Stato del grafo: nodi, link, motore database, dimensione embedding
`ns_store_turn`	Salva un turno: keyword, topic, domain, intent, sentiment, link. Genera embedding 256-dim automaticamente
`ns_get_context`	Recupera contesto correlato da keyword e profondita (1-3 hop)
`ns_find_candidates`	Screening: trova keyword esistenti simili (Turso vector search o Python fallback)
`ns_vector_search`	Ricerca semantica vettoriale: cosine similarity su embedding 256-dim
`ns_summary`	Riepilogo testuale del grafo: keyword top, link recenti, salute
`ns_forgotten`	Trova concetti non toccati da N turni (salience in decadimento)
`ns_prune`	Potatura link tangenziali inattivi
`ns_dedup`	Attiva/disattiva deduplicazione keyword
`ns_flash`	Attiva/disattiva flash semantici
`ns_reset`	Azzera il grafo
`ns_export`	Esporta il grafo completo in JSON

API Key & Ambiente

Dove ottenere le chiavi

Provider	Dove creare la key	Variabile d'ambiente consigliata
OpenAI	platform.openai.com/api-keys	`OPENAI_API_KEY`
Anthropic	console.anthropic.com/settings/keys	`ANTHROPIC_API_KEY`
Gemini	aistudio.google.com/apikey	`GEMINI_API_KEY`
Azure OpenAI	portal.azure.com → Risorsa OpenAI → `Keys and Endpoint`	`AZURE_OPENAI_API_KEY`
Ollama	— (locale, nessuna key)	—
Compatibile	Fornita dal provider (es. Groq, Perplexity, Together, DeepSeek, Mistral)	`OPENAI_API_KEY`

Setup rapido ambiente

# PowerShell (Windows) — aggiungi al $PROFILE
$env:OPENAI_API_KEY = "sk-proj-..."
$env:ANTHROPIC_API_KEY = "sk-ant-..."
$env:GEMINI_API_KEY = "AIzaSy..."
$env:AZURE_OPENAI_API_KEY = "sk-..."

# Bash (Linux/macOS) — aggiungi a ~/.bashrc o ~/.zshrc
export OPENAI_API_KEY="sk-proj-..."
export ANTHROPIC_API_KEY="sk-ant-..."
export GEMINI_API_KEY="AIzaSy..."
export AZURE_OPENAI_API_KEY="sk-..."

Oppure crea un file .env nella directory del progetto:

OPENAI_API_KEY=sk-proj-...
ANTHROPIC_API_KEY=sk-ant-...
GEMINI_API_KEY=AIzaSy...
AZURE_OPENAI_API_KEY=sk-...

Le variabili d'ambiente vengono lette automaticamente da run_interactive.py se il flag --api-key non viene passato.

Config file persistente

Neural-Stimulus supporta un file di configurazione in ~/.neural-stimulus/config.json. I parametri salvati diventano i default per le sessioni successive.

# Salva provider + modello come default
python run_interactive.py --provider openai --model gpt-4o --save-config

# Nelle sessioni successive basta:
python run_interactive.py
# (carica provider e modello dal config)

Il file ~/.neural-stimulus/config.json generato:

{
  "provider": "openai",
  "model": "gpt-4o",
  "fast_model": "gpt-4o-mini",
  "dedup": false,
  "summary_every": 0,
  "db_path": "graph.db"
}

Ordine di precedenza: CLI args > config file > default del provider.

Opzioni salvabili: --provider, --model, --fast-model, --dedup, --summary-every, --db-path, --azure-endpoint, --azure-api-version, --base-url.

Verifica connessione

Dopo l'installazione, verifica che tutto funzioni:

# Verifica MCP server (deve avviarsi e restare in ascolto senza errori)
python mcp_server.py
# (nessun output = OK. Ctrl+C per fermare)

# Verifica LLM provider (es. Ollama)
python run_interactive.py --provider ollama
# Deve apparire la CLI interattiva con "Ollama" come model engine

# Verifica stato grafo
python -c "from neural_stimulus import NeuralStimulus; ns=NeuralStimulus(); print(ns._status())"

Modalità interattiva CLI

Oltre al server MCP, Neural-Stimulus include una chat interattiva che usa direttamente un LLM per estrarre e collegare concetti. Supporta 6 provider LLM. Le API key possono essere passate via --api-key, via variabile d'ambiente, o via file .env.

Provider supportati

Provider	Pacchetto	Comando	Modello default	Modello fast default
Ollama (locale)	`ollama`	`--provider ollama`	`qwen2.5:14b`	`qwen2.5:3b`
OpenAI	`openai`	`--provider openai --api-key sk-...`	`gpt-4o`	`gpt-4o-mini`
Azure OpenAI	`openai`	`--provider azure --azure-endpoint https://... --api-key ...`	`gpt-4o`	`gpt-4o-mini`
Anthropic (Claude)	`anthropic`	`--provider anthropic --api-key sk-...`	`claude-sonnet-4-5`	`claude-haiku-3-5`
Google Gemini	`google-generativeai`	`--provider gemini --api-key ...`	`gemini-2.5-pro`	`gemini-2.0-flash-lite`
Compatibile (LM Studio, Groq, vLLM, LiteLLM, Perplexity, DeepSeek, Mistral AI, Together, ...)	`openai`	`--provider compatible --base-url http://...`	`mistral`	stesso del principale

Installazione provider

# Tutti i provider
pip install ollama openai anthropic google-generativeai

# O singolarmente
pip install ollama                   # solo Ollama locale
pip install openai                   # OpenAI + Azure OpenAI + endpoint compatibili
pip install anthropic                # Anthropic Claude
pip install google-generativeai      # Google Gemini

Su Windows l'installer (install.ps1) chiede interattivamente quali provider installare.

Utilizzo

# Ollama (modelli locali, nessuna API key)
python run_interactive.py --provider ollama
python run_interactive.py --provider ollama --model llama3.2:8b

# OpenAI
python run_interactive.py --provider openai --api-key sk-proj-...

# Azure OpenAI
python run_interactive.py --provider azure --azure-endpoint https://tizio.openai.azure.com --api-key sk-...

# Anthropic Claude
python run_interactive.py --provider anthropic --api-key sk-ant-...

# Google Gemini
python run_interactive.py --provider gemini --api-key AIzaSy...

# Endpoint compatibile (es. LM Studio locale)
python run_interactive.py --provider compatible --base-url http://localhost:1234/v1

# Endpoint compatibile (es. Groq)
python run_interactive.py --provider compatible --base-url https://api.groq.com/openai/v1 --api-key gsk_...

# Endpoint compatibile (es. Perplexity)
python run_interactive.py --provider compatible --base-url https://api.perplexity.ai --api-key pplx-...

# Endpoint compatibile (es. DeepSeek)
python run_interactive.py --provider compatible --base-url https://api.deepseek.com/v1 --api-key sk-...

# Endpoint compatibile (es. Mistral AI)
python run_interactive.py --provider compatible --base-url https://api.mistral.ai/v1 --api-key ...

Opzioni CLI

Opzione	Default	Descrizione
`--provider`	`ollama`	Provider LLM: `ollama`, `openai`, `anthropic`, `gemini`, `azure`, `compatible`
`--api-key`	—	Chiave API (letta da env var se omessa)
`--azure-endpoint`	—	Endpoint Azure OpenAI (es. `https://tizio.openai.azure.com`)
`--azure-api-version`	`2024-10-21`	Versione API Azure OpenAI
`--base-url`	—	URL base per provider compatible (es. `http://localhost:1234/v1`)
`--model`	(default del provider)	Modello principale per estrazione e chat
`--fast-model`	(default del provider)	Modello leggero per estrazione rapida (M5)
`--dedup`	off	Deduplica keyword automaticamente
`--summary-every`	0	Riassunto ogni N turni (0 = disabilitato)
`--db-path`	`graph.db`	Path del file SQLite per persistenza
`--save-config`	off	Salva i parametri come default in `~/.neural-stimulus/config.json`

Esempi pratici

# Chat con Ollama e modelli sovrascritti
python run_interactive.py --provider ollama --model llama3.2:8b --fast-model llama3.2:3b

# Chat con OpenAI GPT-4o, dedup attivo
python run_interactive.py --provider openai --api-key $OPENAI_API_KEY --dedup

# Chat con Azure OpenAI
python run_interactive.py --provider azure --azure-endpoint https://tizio.openai.azure.com --model mio-deploy-gpt4

# Chat con Claude, riassunto ogni 5 turni
python run_interactive.py --provider anthropic --api-key $ANTHROPIC_API_KEY --summary-every 5

# Chat con Gemini, path DB personalizzato
python run_interactive.py --provider gemini --api-key $GEMINI_API_KEY --db-path progetti.db

# Compatibile: LiteLLM proxy
python run_interactive.py --provider compatible --base-url http://localhost:4000/v1 --model gpt-4

# Compatibile: vLLM
python run_interactive.py --provider compatible --base-url http://localhost:8000/v1 --model mistralai/Mistral-7B

# Salva provider + modello come default
python run_interactive.py --provider openai --model gpt-4o --save-config

# Usa la config salvata (non servono flag)
python run_interactive.py

Comandi in-chat

Durante la sessione interattiva:

Comando	Azione
`/ns status`	Mostra stato del grafo
`/ns summary`	Riepilogo del grafo
`/ns prune`	Potatura link tangenziali
`/ns flash`	Attiva/disattiva flash semantici
`/ns export`	Esporta grafo in JSON
`/ns reset`	Azzera il grafo
`/exit` o `Ctrl+C`	Esci

Flusso di lavoro tipico

Ecco come l'LLM usa Neural-Stimulus durante una sessione:

All'avvio

LLM: "ns_status"                        ← c'e' un grafo salvato?
     "ns_get_context(['Spring','JPA'])" ← riprende i concetti principali

Ogni 3-5 turni di chat

LLM: "ns_find_candidates(['Kafka','event-driven'])"  ← screening vettoriale
     "ns_store_turn(
        topic='messaggistica asincrona',
        keywords=['Kafka','event-driven','pub-sub'],
        domain='backend',
        intent='task',
        sentiment='neutro',
        links=[
          {source:'Kafka', target:'microservices',
           link_type:'evoluzione', weight:'forte',
           rationale:'Kafka e lo standard per event-driven nei microservizi'}
        ]
     )"   ← embedding generato automaticamente per ogni keyword

Esplorazione

LLM: "ns_vector_search(['CQRS','saga'], top_n=5)"   ← cerca per similarita semantica
     "ns_get_context(['Kafka'], depth=2)"              ← esplora vicini nel grafo

Embedding vettoriali

Neural-Stimulus supporta due modalita di embedding, selezionate automaticamente all'avvio:

Modalita	Dipendenza	Dimensione	Qualita
Semantico (predefinito)	`fastembed` (opzionale)	384-dim	capisce il significato
Feature hashing (fallback)	`hashlib` (stdlib)	256-dim	solo similarita lessicale

Embedding semantico (fastembed)

Se fastembed e installato, il server usa sentence-transformers/all-MiniLM-L6-v2 (ONNX, ~80MB modello, ~200MB totali):

"database" → [0.23, -0.45, 0.12, ...]  ← vicino a "SQL", "table", "query"
"pizza"    → [-0.08, 0.31, 0.02, ...]   ← lontano da "database" (cos=0.15)

Installazione:

pip install fastembed

All'avvio, i nodi esistenti vengono automaticamente ri-embedati in 384-dim.

Feature hashing (fallback)

Se fastembed non e disponibile, ogni keyword viene convertita in un vettore 256-dim deterministico via character n-gram feature hashing:

keyword → caratteri minuscoli
        → estrae 2-gram e 3-gram
        → per ogni n-gram: MD5(posizione) + MD5(segno)
        → somma i contributi nel vettore
        → L2 normalize

Zero dipendenze: solo hashlib e struct dalla libreria standard
Deterministico: stessa keyword → stesso vettore, su qualsiasi macchina
Vicino lessicale: keyword che condividono caratteri (es. "database" e "Data") hanno vettori simili
Ricerca SQL: con Turso, vector_distance_cos(embedding, query) calcola la similarita internamente
Niente cache Python: i vettori non vengono caricati in memoria — query SQL diretta

Esempio reale (feature hashing)

Query: "ORM, database, query"
  Spring Data   cos=0.3587  ← "Data" condivide n-gram con "database"
  JPA           cos=0.1898  ← tecnologia ORM
  Kubernetes    cos=0.1196
  Hibernate     cos=0.0797  ← implementazione ORM
  Spring Boot   cos=0.0377

Troubleshooting

`vector_distance_cos` — no such function

sqlite3.DatabaseError: no such function: vector_distance_cos

Causa: pyturso non caricato correttamente (engine SQLite locale invece di Turso).

Soluzione:

# Verifica che pyturso sia installato nel venv corretto
pip list | findstr pyturso

# Reinstalla
pip install --force-reinstall pyturso

# Se Rust manca: installa dal sito https://rustup.rs

Rust non compila su Windows

error: linker `link.exe` not found

Causa: pyturso compila da sorgente su Windows e richiede il linker MSVC.

Soluzione: Installa Visual Studio Build Tools con il workload "C++ desktop development":

winget install Microsoft.VisualStudio.2022.BuildTools --override "--add Microsoft.VisualStudio.Workload.VCTools --includeRecommended"

Oppure usa il container Docker (vedi Installazione Docker).

`ModuleNotFoundError: No module named 'openai'`

ImportError: Installa il pacchetto: pip install openai

Causa: provider richiesto ma pacchetto non installato.

Soluzione:

pip install openai      # per OpenAI, Azure OpenAI, Compatibile
pip install anthropic   # per Anthropic Claude
pip install google-generativeai  # per Google Gemini

Il server MCP non si connette

Verifica che run_mcp.bat esista nella directory di installazione
Verifica che python sia nel PATH e punti al venv
Prova ad avviare manualmente: python mcp_server.py
Se l'output mostra errori, condividili per debug

Connessione API fallisce

# Test rapido con curl (es. OpenAI)
curl https://api.openai.com/v1/models -H "Authorization: Bearer $OPENAI_API_KEY"

# Test rapido (es. Azure)
curl https://tizio.openai.azure.com/openai/models?api-version=2024-10-21 -H "api-key: $AZURE_OPENAI_API_KEY"

# Test rapido (es. Ollama locale)
curl http://localhost:11434/api/tags

Errori Azure OpenAI

Errore	Causa probabile	Soluzione
`DeploymentNotFound`	Il nome deployment non esiste	Usa il nome deployment esatto dal portale Azure
`AccessDenied`	API key errata o scaduta	Rigenera la key dal portale
`InvalidApiVersion`	`api_version` non valida	Usa `2024-10-21` o la versione supportata dalla regione
`RateLimitExceeded`	Troppe richieste	Riduci concorrenza o aumenta quota

Riepilogo da terminale

L'LLM non deve sprecare token per leggere il grafo: usa .\ns-summary.ps1 dal terminale, che legge graph.db direttamente.

.\ns-summary.ps1

Output:

Turni: 4  |  Nodi: 20  |  Link: 10 (attivi 10)
Forti: 5  |  Medi: 5  |  Tipi di link: 5
Motore: Turso  |  Embedding: 384dim (o 256dim fallback)
Keyword top:
  microservices        salience= 7  turno=2
  JPA                  salience= 6  turno=2
  ...

File del progetto

File	Ruolo
`mcp_server.py`	Server MCP principale (12 tool, embedding semantico/feature hashing, Turso/SQLite)
`run_interactive.py`	Chat interattiva CLI (supporta 6 provider LLM)
`neural_stimulus.py`	Engine: grafo semantico + client LLM (Ollama, OpenAI, Anthropic, Gemini, Azure, Compatibile)
`install.ps1`	Installer Windows (Rust + pyturso + MCP + provider LLM)
`auto-context.md`	Istruzioni per priming ricorrente dell'LLM
`SKILL_base.md`	Skill minimale per OpenCode/Claude
`SKILL_full.md`	Skill completa con tutti i moduli
`run_mcp.bat`	Launcher stdio per MCP
`ns-summary.ps1`	Riepilogo del grafo da terminale (zero token)
`ns_summary_query.py`	Query engine per ns-summary
`requirements.txt`	Dipendenze Python (pyturso + MCP SDK + provider opzionali)
`pyproject.toml`	Metadati progetto
`opencode.example.json`	Esempio configurazione MCP

Testing & Reverse Engineering (26/06/2026)

Sessione di test completo su tutte le funzionalità MCP:

ns_vector_search — embedding 384-dim con pyturso vector_distance_cos(), match "Kotlin coroutine async" → Kotlin Flows a 0.52
ns_find_candidates — screening TF-IDF candidati pre-store
ns_get_context — depth 1-3: contesto diretto e catene di link
ns_store_turn — salvataggio turno con link tipizzati
ns_forgotten — rilevamento 8 concetti in decadimento (3+ turni inattivi)
ns_flash / ns_dedup — toggle funzionanti
ns_prune — 0 link tangenziali potati (grafo pulito)
ns_status — salute: strong+medio 100%, 5 tipi link, nodi/turno 5.4

Priming automatico (attivato)

Ogni 3-5 turni significativi, l'agente LLM:

Salva i concetti emersi (ns_store_turn)
Rinfresca il contesto dei topic caldi (ns_get_context depth 1-2)
Stimola flash semantici laterali (ns_get_context depth 2-3)

Il ciclo è comportamentale (istruzioni in auto-context.md), non richiede modifica al codice del server.

Licenza

MIT — fai quello che vuoi, anche commerciale.

This server cannot be installed

license - permissive license

quality - not tested

maintenance

How are these scores calculated?

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Latest Blog Posts

Lightport: Open-Sourcing Glama's AI Gateway
By punkpeye on April 27, 2026.
open source
OpenAI
Tool Definition Quality Score (TDQS)
By punkpeye on April 3, 2026.
mcp
The Hackers Who Tracked My Sleep Cycle
By punkpeye on March 26, 2026.
security

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/recla93/NeuralStimulus'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

Neural-Stimulus v3.1 — Turso Native Vector Search

Indice

Cosa fa

Architettura

Installazione

Windows (automatico)

Linux / macOS (manuale)

Docker

Configurazione per ogni client MCP

OpenCode

Claude Code

Claude Desktop

Cursor

Windsurf

Gemini CLI (Google Antigravity)

OpenAI Codex / ChatGPT

VS Code (GitHub Copilot)

Zed

Continue.dev

Cody (Sourcegraph)

Amazon Q Developer

Riepilogo configurazioni

Tool MCP disponibili

API Key & Ambiente

Dove ottenere le chiavi

Setup rapido ambiente

Config file persistente

Verifica connessione

Modalità interattiva CLI

Provider supportati

Installazione provider

Utilizzo

Opzioni CLI

Esempi pratici

Comandi in-chat

Flusso di lavoro tipico

All'avvio

Ogni 3-5 turni di chat

Esplorazione

Embedding vettoriali

Embedding semantico (fastembed)

Feature hashing (fallback)

Esempio reale (feature hashing)

Troubleshooting

vector_distance_cos — no such function

Rust non compila su Windows

ModuleNotFoundError: No module named 'openai'

Il server MCP non si connette

Connessione API fallisce

Errori Azure OpenAI

Riepilogo da terminale

File del progetto

Testing & Reverse Engineering (26/06/2026)

Priming automatico (attivato)

Licenza

Resources

Looking for Admin?

Latest Blog Posts

MCP directory API

`vector_distance_cos` — no such function

`ModuleNotFoundError: No module named 'openai'`