Power your agent
คำสั่งของผู้เผยแพร่เอง ไม่ใช่เอนด์พอยต์ของ PlugMCP
Host a copy with our keys and logs.
npx -y [email protected]Claude Code ไม่มีลิงก์ติดตั้งสำหรับคำสั่งแบบโลคัล ให้คัดลอกคำสั่งด้านล่างแล้วรันในเทอร์มินัล
claude mcp add cscsoftware-aidex -- npx -y aidex-mcp@1.8.0รันในเทอร์มินัล
{ "mcpServers": { "cscsoftware-aidex": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}claude_desktop_config.json
URL แบบรีโมตหรือคำสั่งบนเครื่องของคุณ? การติดตั้งสองแบบต่างกันอย่างไร
รันบน PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
เปิดThe persistent brain for AI coding agents.
AiDex is an MCP server that gives AI coding assistants a memory, semantic search, and live telemetry — local-first, model-agnostic. Works with any MCP-compatible AI assistant: Claude Code, Claude Desktop, Cursor, Windsurf, Gemini CLI, VS Code Copilot, and more.
🧠 Memory — Tasks, notes, and session-notes survive every chat. Auto-logged history, scheduled tasks, cross-session continuity. Your AI knows tomorrow what mattered today.
🔍 Search — Three modes: exact (identifier), semantic (concept), hybrid (RRF fusion of both). Embeds code, docs, and workspace items into one ranking. Cross-project — every repo in one query. Optional LLM layer translates non-English queries and reranks results.
🌐 Telemetry — LogHub receives live logs from any app via HTTP (no SDK). The AI watches what your code actually does, not just what it says. Live-streamed in the Viewer.
14 languages — C#, TypeScript, JavaScript, Rust, Python, C, C++, Java, Go, PHP, Ruby, HCL/Terraform, Kotlin, Swift — plus Astro frontmatter
# Find where "PlayerHealth" is defined — 1 call, ~50 tokens
aidex_query({ term: "PlayerHealth" })
→ Engine.cs:45, Player.cs:23, UI.cs:156
# All methods in a file — without reading the whole file
aidex_signature({ file: "src/Engine.cs" })
→ class GameEngine { Update(), Render(), LoadScene(), ... }
# What changed in the last 2 hours?
aidex_query({ term: "render", modified_since: "2h" })
# Search across ALL your projects at once
aidex_global_query({ term: "TransparentWindow", mode: "contains" })
→ Found in: LibWebAppGpu (3 hits), DebugViewer (1 hit)
# Leave a note for your next session
aidex_note({ path: ".", note: "Test the parser fix after restart" })
# Create a task while working
aidex_task({ path: ".", action: "create", title: "Fix edge case in parser", priority: 1, tags: "bug" })
v2.0 added semantic search via locally-run embeddings — your AI can find a function even when it doesn't know the exact identifier.
One ranking, all kinds. A query like "how to write logs from external programs" surfaces the README's ## Log Hub section first, then the log method in commands/log.ts, then any related task.
// Enable embeddings on a project (one-time, ~30s for AiDex itself, cached afterwards)
aidex_init({ path: ".", embeddings: true })
// Search
aidex_search({ query: "how do we batch requests to the LLM", path: "." })
aidex_search({ query: "retry with backoff", scope: "all" }) // across every embedded project
Or use the Settings tab in the Viewer (aidex_settings({ path: ".", open: true })) — toggles for embeddings, LLM provider, model, and the privacy switch.
When an Anthropic / OpenAI / OpenRouter / Ollama / HuggingFace API key is configured, AiDex can:
Privacy switch llm_send_code defaults to off — only your literal query and metadata (paths, names, anchors) are sent. Code bodies stay local. Per-project, easy to verify in Settings.
Local-first: works fully offline with pure embeddings. The LLM layer is opt-in, never required.
Every time your AI assistant searches for code, it:
A single "Where is X defined?" question can eat 2,000+ tokens. Do that 10 times and you've burned half your context on navigation alone.
Index once, query forever:
# Before: grep flooding your context
AI: grep "PlayerHealth" → 200 hits in 40 files
AI: read File1.cs, File2.cs, File3.cs...
→ 2000+ tokens consumed, 5+ tool calls
# After: precise results, minimal context
AI: aidex_query({ term: "PlayerHealth" })
→ Engine.cs:45, Player.cs:23, UI.cs:156
→ ~50 tokens, 1 tool call
Result: 50-80% less context used for code navigation.
The real cost of grep: Every grep result includes surrounding context. Search for User in a large project and you'll get hundreds of hits - comments, strings, partial matches. Your AI reads through all of them, burning context tokens on noise.
AiDex indexes identifiers: It uses Tree-sitter to actually parse your code. When you search for User, you get the class definition, the method parameters, the variable declarations - not every comment that mentions "user".
Index your project once (~1 second per 1000 files)
aidex_init({ path: "/path/to/project" })
AI searches the index instead of grepping
aidex_query({ term: "Calculate", mode: "starts_with" })
→ All functions starting with "Calculate" + exact line numbers
aidex_query({ term: "Player", modified_since: "2h" })
→ Only matches changed in the last 2 hours
Get file overviews without reading entire files
aidex_signature({ file: "src/Engine.cs" })
→ All classes, methods, and their signatures
The index lives in .aidex/index.db (SQLite) - fast, portable, no external dependencies.
node --version)
brew install node or nvm install 20 && nvm use 20nvm, the repo ships a .nvmrc — nvm use picks the right version automatically.npm install -g aidex-mcp
That's it. Setup runs automatically after install — it detects your installed AI clients (Claude Code, Claude Desktop, Cursor, Windsurf, Gemini CLI, VS Code Copilot) and registers AiDex as an MCP server. It also adds usage instructions to your AI's config (~/.claude/CLAUDE.md, ~/.gemini/GEMINI.md).
To re-run setup manually: aidex setup | To unregister: aidex unsetup | To skip auto-setup: AIDEX_NO_SETUP=1 npm install -g aidex-mcp
For Claude Code (~/.claude/settings.json or ~/.claude.json):
{
"mcpServers": {
"aidex": {
"type": "stdio",
"command": "aidex",
"env": {}
}
}
}
For Claude Desktop (%APPDATA%/Claude/claude_desktop_config.json on Windows):
{
"mcpServers": {
"aidex": {
"command": "aidex"
}
}
}
Note: Both
aidexandaidex-mcpwork as command names.
Important: The server name in your config determines the MCP tool prefix. Use
"aidex"as shown above — this gives you tool names likeaidex_query,aidex_signature, etc. Using a different name (e.g.,"codegraph") would change the prefix accordingly.
For Gemini CLI (~/.gemini/settings.json):
{
"mcpServers": {
"aidex": {
"command": "aidex"
}
}
}
For VS Code Copilot (run MCP: Open User Configuration in Command Palette):
{
"servers": {
"aidex": {
"type": "stdio",
"command": "aidex"
}
}
}
For other MCP clients: See your client's documentation for MCP server configuration.
Add to your AI's instructions (e.g., ~/.claude/CLAUDE.md for Claude Code, or the equivalent for your AI client). This tells the AI when and how to use AiDex instead of grepping:
## AiDex - Persistent Code Index (MCP Server)
AiDex provides fast, precise code search through a pre-built index.
**Always prefer AiDex over Grep/Glob for code searches.**
### REQUIRED: Before using Grep/Glob/Read for code searches
Do I want to search code? ├── .aidex/ exists → STOP! Use AiDex instead ├── .aidex/ missing → run aidex_init (don't ask), THEN use AiDex └── Config/Logs/Text → Grep/Read is fine
**NEVER do this when .aidex/ exists:**
- ❌ `Grep pattern="functionName"` → ✅ `aidex_query term="functionName"`
- ❌ `Grep pattern="class.*Name"` → ✅ `aidex_query term="Name" mode="contains"`
- ❌ `Read file.cs` to see methods → ✅ `aidex_signature file="file.cs"`
- ❌ `Glob pattern="**/*.cs"` + Read → ✅ `aidex_signatures pattern="**/*.cs"`
### Session-Start Rule (REQUIRED — every session, no exceptions)
1. Call `aidex_session({ path: "<project>" })` — detects external changes, auto-reindexes
2. If `.aidex/` does NOT exist → run `aidex_init` automatically (don't ask)
3. If a session note exists → **show it to the user** before continuing
4. **Before ending a session:** always leave a note about what to do next
### Question → Right Tool
| Question | Tool |
|----------|------|
| "Where is X defined?" | `aidex_query term="X"` |
| "Find anything containing X" | `aidex_query term="X" mode="contains"` |
| "All functions starting with X" | `aidex_query term="X" mode="starts_with"` |
| "What methods does file Y have?" | `aidex_signature file="Y"` |
| "Explore all files in src/" | `aidex_signatures pattern="src/**"` |
| "Project overview" | `aidex_summary` + `aidex_tree` |
| "What changed recently?" | `aidex_query term="X" modified_since="2h"` |
| "What files changed today?" | `aidex_files path="." modified_since="8h"` |
| "Have I ever written X?" | `aidex_global_query term="X" mode="contains"` |
| "Which project has class Y?" | `aidex_global_signatures term="Y" kind="class"` |
| "All indexed projects?" | `aidex_global_status` |
### Search Modes
- **`exact`** (default): Finds only the exact identifier — `log` won't match `catalog`
- **`contains`**: Finds identifiers containing the term — `render` matches `preRenderSetup`
- **`starts_with`**: Finds identifiers starting with the term — `Update` matches `UpdatePlayer`, `UpdateUI`
### All Tools (30)
| Category | Tools | Purpose |
|----------|-------|---------|
| Search & Index | `aidex_init`, `aidex_query`, `aidex_update`, `aidex_remove`, `aidex_status` | Index project, search identifiers (exact/contains/starts_with), time filter |
| Signatures | `aidex_signature`, `aidex_signatures` | Get classes + methods without reading files |
| Overview | `aidex_summary`, `aidex_tree`, `aidex_describe`, `aidex_files` | Entry points, file tree, file listing by type |
| Cross-Project | `aidex_link`, `aidex_unlink`, `aidex_links`, `aidex_scan` | Link dependencies, discover projects |
| Global Search | `aidex_global_init`, `aidex_global_query`, `aidex_global_signatures`, `aidex_global_status`, `aidex_global_refresh` | Search across ALL projects |
| Guidelines | `aidex_global_guideline` | Persistent AI instructions & conventions (key-value, global) |
| Sessions | `aidex_session`, `aidex_note` | Track sessions, leave notes (with searchable history) |
| Tasks | `aidex_task`, `aidex_tasks` | Built-in backlog with priorities, tags, summaries, auto-logged history, scheduled/recurring tasks |
| Log Hub | `aidex_log` | Universal log receiver — any program sends logs via HTTP, AI queries them, live in Viewer |
| Screenshots | `aidex_screenshot`, `aidex_windows` | Screen capture with LLM optimization (scale + color reduction, no index needed) |
| Viewer | `aidex_viewer` | Interactive browser UI with file tree, signatures, tasks, and live logs |
**14 languages:** C#, TypeScript, JavaScript, Rust, Python, C, C++, Java, Go, PHP, Ruby, HCL/Terraform, Kotlin, Swift — plus Astro frontmatter
### Session Notes
Leave notes for the next session — they persist in the database:
aidex_note({ path: ".", note: "Test the fix after restart" }) # Write aidex_note({ path: ".", note: "Also check edge cases", append: true }) # Append aidex_note({ path: "." }) # Read aidex_note({ path: ".", search: "parser" }) # Search history aidex_note({ path: ".", clear: true }) # Clear
- **Before ending a session:** automatically leave a note about next steps
- **User says "remember for next session: ..."** → write it immediately
### Task Backlog
Track TODOs, bugs, and features right next to your code index:
aidex_task({ path: ".", action: "create", title: "Fix bug", priority: 1, tags: "bug" }) aidex_task({ path: ".", action: "update", id: 1, status: "done" }) aidex_task({ path: ".", action: "log", id: 1, note: "Root cause found" }) aidex_tasks({ path: ".", status: "active" })
aidex_task({ path: ".", action: "create", title: "Check PR status", due: "3d", interval: "3d", task_action: "gh pr list" })
Priority: 1=high, 2=medium, 3=low | Status: `backlog → active → done | cancelled`
### Global Search (across all projects)
aidex_global_init({ path: "/path/to/all/repos" }) # Scan & register aidex_global_init({ path: "...", index_unindexed: true }) # + auto-index small projects aidex_global_query({ term: "TransparentWindow", mode: "contains" }) # Search everywhere aidex_global_signatures({ term: "Render", kind: "method" }) # Find methods everywhere aidex_global_status({ sort: "recent" }) # List all projects
### Screenshots
aidex_screenshot() # Full screen aidex_screenshot({ mode: "active_window" }) # Active window aidex_screenshot({ mode: "window", window_title: "VS Code" }) # Specific window aidex_screenshot({ scale: 0.5, colors: 2 }) # B&W, half size (ideal for LLM) aidex_screenshot({ colors: 16 }) # 16 colors (UI readable) aidex_windows({ filter: "chrome" }) # Find window titles
No index needed. Returns file path → use `Read` to view immediately.
**LLM optimization strategy:** Always start with aggressive settings, then retry if unreadable:
1. First try: `scale: 0.5, colors: 2` (B&W, half size — smallest possible)
2. If unreadable: retry with `colors: 16` (adds shading for UI elements)
3. If still unclear: `scale: 0.75` or omit `colors` for full quality
4. **Remember** what works for each window/app during the session — don't retry every time.
Ask your AI: "Index this project with AiDex"
Or manually in the AI chat:
aidex_init({ path: "/path/to/your/project" })
Track what changed recently with modified_since and modified_before:
aidex_query({ term: "render", modified_since: "2h" }) # Last 2 hours
aidex_query({ term: "User", modified_since: "1d" }) # Last day
aidex_query({ term: "API", modified_since: "1w" }) # Last week
Supported formats:
30m (minutes), 2h (hours), 1d (days), 1w (weeks)2026-01-27 or 2026-01-27T14:30:00Perfect for questions like "What did I change in the last hour?"
AiDex indexes ALL files in your project (not just code), letting you query the structure:
aidex_files({ path: ".", type: "config" }) # All config files
aidex_files({ path: ".", type: "test" }) # All test files
aidex_files({ path: ".", pattern: "**/*.md" }) # All markdown files
aidex_files({ path: ".", modified_since: "30m" }) # Changed this session
File types: code, config, doc, asset, test, other, dir
Use modified_since to find files changed in this session - perfect for "What did I edit?"
Leave reminders for the next session - no more losing context between chats:
aidex_note({ path: ".", note: "Test the glob fix after restart" }) # Write
aidex_note({ path: ".", note: "Also check edge cases", append: true }) # Append
aidex_note({ path: "." }) # Read
aidex_note({ path: ".", clear: true }) # Clear
Note History (v1.10): Old notes are automatically archived when overwritten or cleared. Browse and search past notes:
aidex_note({ path: ".", history: true }) # Browse archived notes (shows summaries)
aidex_note({ path: ".", search: "parser" }) # Search note history (searches summaries too)
aidex_note({ path: ".", history: true, limit: 5 }) # Last 5 archived notes
Note Summaries (v1.15): Provide a summary when writing/clearing a note — the archived note gets this one-sentence description. History then shows summaries instead of truncated text:
aidex_note({ path: ".", note: "New focus", summary: "Previous session: finished parser refactoring" })
Use cases:
Notes are stored in the SQLite database (.aidex/index.db) and persist indefinitely.
Keep your project tasks right next to your code index - no Jira, no Trello, no context switching:
aidex_task({ path: ".", action: "create", title: "Fix parser bug", priority: 1, tags: "bug", summary: "Parser crashes on nested generics in C#" })
aidex_task({ path: ".", action: "update", id: 1, status: "done" })
aidex_task({ path: ".", action: "log", id: 1, note: "Root cause: unbounded buffer" })
aidex_tasks({ path: ".", status: "active" })
Tasks can have due dates and repeat intervals. Overdue tasks are reported at every session start across ALL projects:
# One-shot: remind in 3 days
aidex_task({ path: ".", action: "create", title: "Review PR", due: "3d", task_action: "Check if PR was submitted" })
# Recurring: check every week
aidex_task({ path: ".", action: "create", title: "Check dependencies", due: "1w", interval: "1w", task_action: "npm outdated" })
# Auto-execute: runs the action automatically when due
aidex_task({ path: ".", action: "create", title: "Refresh stats", due: "1d", interval: "1d", auto_go: true })
Due formats: Relative ("30m", "2h", "3d", "1w") or ISO date ("2026-04-10")
At every aidex_session call, the Task Scheduler checks ~/.aidex/global.db for due tasks across all projects — even if you're working on a different project. Recurring tasks automatically advance their due date after each trigger.
Features:
backlog → active → done | cancelledbug, feature, docs, etc.).aidex/index.dbYour AI assistant can create tasks while working ("found a bug in the parser, add it to the backlog"), track progress, and pick up where you left off next session.
Search across ALL your indexed projects at once. Perfect for "Have I ever written a transparent window?" or "Where did I use that algorithm?"
aidex_global_init({ path: "Q:/develop" }) # Scan & register
aidex_global_init({ path: "Q:/develop", exclude: ["llama.cpp"] }) # Skip external repos
aidex_global_init({ path: "Q:/develop", index_unindexed: true }) # Auto-index all found projects
aidex_global_init({ path: "Q:/develop", index_unindexed: true, show_progress: true }) # With browser progress UI
This scans your project directory, registers all AiDex-indexed projects in a global database (~/.aidex/global.db), and reports any unindexed projects it finds by detecting project markers (.csproj, package.json, Cargo.toml, etc.).
With index_unindexed: true, it also auto-indexes all discovered projects with ≤500 code files. Larger projects are listed separately for user decision. Add show_progress: true to open a live progress UI in your browser (http://localhost:3334).
aidex_global_query({ term: "TransparentWindow" }) # Exact match
aidex_global_query({ term: "transparent", mode: "contains" }) # Fuzzy search
aidex_global_signatures({ term: "Render", kind: "method" }) # Find methods
aidex_global_signatures({ term: "Player", kind: "class" }) # Find classes
ATTACH DATABASE to query project databases directly — no data copying.aidex/index.db as the single source of truthMyApp/ is removed when MyApp/Frontend/ and MyApp/Backend/ exist as separate indexed projects)aidex_global_status() # List all projects
aidex_global_status({ sort: "recent" }) # Most recently indexed first
aidex_global_refresh() # Update stats, remove stale
Store persistent coding conventions, review checklists, and AI instructions in a single place — shared across all projects.
aidex_global_guideline({ action: "set", key: "review", value: "Always check: error handling, null safety, no hardcoded strings" })
aidex_global_guideline({ action: "set", key: "style", value: "Use PascalCase for classes, camelCase for methods, 4-space indent" })
aidex_global_guideline({ action: "get", key: "review" }) # Retrieve a guideline
aidex_global_guideline({ action: "list" }) # Show all guidelines
aidex_global_guideline({ action: "list", filter: "code" }) # Filter by name
aidex_global_guideline({ action: "delete", key: "old-rule" }) # Remove a guideline
Use cases:
Guidelines are stored in ~/.aidex/global.db — available across all your projects without aidex_init. Ask your AI: "Load the review guideline and apply it to this file."
Turn any program into a log source for your AI assistant. Your app sends logs via HTTP POST, the AI queries them via MCP, and you see them live in the Viewer — zero dependencies, zero setup in your code.
Your Program ──HTTP POST──→ AiDex Log Hub (port 3335) ──→ Ring Buffer
│ │
│ WebSocket │ MCP query
↓ ↓
Viewer (Logs tab) AI Assistant
(you see live) (queries & analyzes)
aidex_log({ action: "init" })aidex_viewer({ path: "." }) — Logs tab shows live stream// C#
await new HttpClient().PostAsJsonAsync("http://localhost:3335/log",
new { level = "info", source = "MyApp", message = "Player spawned", data = new { x = 10, y = 20 } });
# Python
requests.post("http://localhost:3335/log", json={"level": "info", "source": "MyApp", "message": "Done"})
// JavaScript
fetch("http://localhost:3335/log", {
method: "POST", headers: {"Content-Type": "application/json"},
body: JSON.stringify({level: "info", source: "MyApp", message: "Started"})
});
# PowerShell
Invoke-RestMethod -Uri http://localhost:3335/log -Method POST -ContentType "application/json" -Body '{"level":"info","source":"Script","message":"Done"}'
Fields: level (debug/info/warn/error), source (app name), message (text, required), data (optional JSON), timestamp (optional, ms)
init is calledpersist: true)query with consume: true removes returned entries — ideal for pollingLogs and dashboard widgets flow app → AI. The Control API is the return channel: AI → app. It turns the Log Hub into a tiny, zero-dependency command bus — so an AI assistant can drive any running program without you writing a server.
The AI sets a command; your app polls for it, runs it, and posts the result back:
AI ──control_set {id,cmd}──→ Hub ←──GET /control── Your App (polls ~1s)
AI ←──control_get──── result ─ Hub ←──POST /control── runs it, posts result + ack
control_set { id, value } — the AI (or a Viewer slider/switch) sets a control slot.GET /control — your app reads all current control values.POST /control — your app writes back results / acknowledgements.POST /control/press { id } — registers one press of a button control. The hub owns the counter, so presses from several open dashboards add up instead of overwriting each other.control_get — the AI reads what the app reported.POST /control/subscribe (optional) — push instead of polling, see below.Push instead of poll. If your app runs its own HTTP server, it can subscribe once with { "port": 8080 } (the hub calls back the sender's address, path defaults to /control) or a full { "url": "http://192.168.1.50:8080/control" }, optionally limited to { "ids": [...] }. From then on every change is POSTed to that URL right away, as the same flat { id: value } map GET /control returns. No idle requests, no latency until the next poll. The hub never blocks on your app (1.5 s timeout, one request in flight, changes in between are merged so the latest value always arrives last), only calls private-network IP addresses, and drops the subscription after 3 failed deliveries — re-subscribing is idempotent, do it whenever you like. POST /control/unsubscribe { url } removes it. Push is an addition, not a replacement: keep a slow poll (~30 s) as a safety net; button counters make a missed push harmless.
A
buttonvalue is a press counter, not a flag — your app polls at its own pace, so compare against the last count you saw rather than testing for "pressed". Any backwards jump means the hub restarted or the panel was cleared: adopt the value, don't read it as a million presses.
Two slots by convention give you full request/response: a *_cmd slot the AI writes, a *_result slot the app writes, and an *_ack counter so each command runs exactly once (bump the command id every time; the app skips any id it has already handled).
That's the whole protocol. A client needs nothing but an HTTP library you already have.
A ~30-line Fusion 360 add-in (urllib only, no SDK) polls GET /control, executes the command on Fusion's main thread, and posts the result back. With nothing else, an AI assistant drove Fusion to parametrically design a complete 3D enclosure — sketches, extrusions, screw-boss domes with heat-set inserts, USB-C cut-outs, reset/button holes — verifying every step by reading back the actual face geometry.
The pattern is universal: anything that can POST and GET — Blender, a CNC controller, a game, a home-automation hub — becomes AI-steerable with a few lines and no bespoke server. Two safety rules carry over from that build:
id and ack it — polling means you'll see the same command repeatedly, so skip what you've already done.The scrolling log stream is great for what happened when — but useless for fast, repeating values (audio levels, buffer fill, FPS, sensor readings). The Debug Dashboard is the opposite: a fixed-slot panel where each value has a permanent spot and overwrites in place instead of scrolling away. Live in the Viewer's Live tab, styled like a hardware monitor (MSI Afterburner / HWiNFO).
It rides on the same Log Hub server — no extra setup. Your program sends widget updates via HTTP POST; sending the same id again updates that widget.
# A single widget — id is the fixed slot, type is required on first send
curl -X POST http://localhost:3335/panel -H "Content-Type: application/json" \
-d '{"id":"mic","type":"plot","value":0.73,"group":"Audio","label":"Mic Level","unit":"dB"}'
# A gauge with threshold zones (green < warn < yellow < crit < red)
curl -X POST http://localhost:3335/panel -H "Content-Type: application/json" \
-d '{"id":"gpu_temp","type":"gauge","value":67,"min":0,"max":100,"warn":75,"crit":90,"group":"Hardware"}'
Fields: id (required), type (label/progress/gauge/plot/slider/number/toggle/button, required on first send), value (number, status string, or number array for a full plot frame), group, label, unit, min, max, warn, crit, color, order.
Endpoints: POST /panel (one), POST /panels (batch), POST /panel/clear ({id} for one, empty for all).
id, so a freshly-opened or reloaded Viewer shows the whole dashboard immediately.type again (plain value-only updates to a cleared id are ignored).A ready-to-run showcase animates all widget types (audio waveform, GPU gauges drifting through their zones, a signal generator cycling sine → sawtooth → triangle → square, latency spikes):
# 1. Start the Log Hub + Viewer from your AI assistant:
# aidex_log({ action: "init" })
# aidex_viewer({ path: "." }) → click the Live tab
# 2. Run the demo (from the AiDex repo root):
node scripts/demo-dashboard.mjs # endless loop, Ctrl+C to stop (clears on exit)
Or use the ▷ Demo button on the Live tab — it copies the run command to your clipboard; paste it into a terminal. (The browser can't spawn a process itself.) It sits in the toolbar even while the dashboard is still empty, since it's how you get your first widgets. scripts/demo-dashboard.ps1 is a one-command launcher that checks the Log Hub first.
Running it twice starts two instances that fight over the same widgets (visible flicker) — stop the old one (Ctrl+C) before starting another.
Take screenshots and reduce them up to 95% for LLM context. A typical screenshot goes from ~100 KB to ~5 KB — that's thousands of tokens saved per image.
Most screenshots in AI context are for reading text — error messages, logs, UI labels. You don't need 16 million colors for that.
aidex_screenshot() # Full screen (full quality)
aidex_screenshot({ mode: "active_window" }) # Active window
aidex_screenshot({ mode: "window", window_title: "VS Code" }) # Specific window
aidex_screenshot({ scale: 0.5, colors: 2 }) # B&W, half size (best for text)
aidex_screenshot({ scale: 0.5, colors: 16 }) # 16 colors (UI readable)
aidex_screenshot({ colors: 256 }) # 256 colors (good quality)
aidex_screenshot({ mode: "region" }) # Interactive selection
aidex_screenshot({ mode: "rect", x: 100, y: 200, width: 800, height: 600 }) # Coordinates
aidex_windows({ filter: "chrome" }) # Find window titles
The tool description tells LLMs to optimize automatically:
scale: 0.5, colors: 2 (smallest possible)colors: 16 (adds shading for UI elements)scale: 0.75 or full colorThis way the AI learns the right settings per app without wasting tokens on oversized images.
.aidex/ neededExplore your indexed project visually in the browser:
aidex_viewer({ path: "." })
Opens http://localhost:3333 with:
/control channelThe Live tab is a live dashboard with fixed slots: send the same id again and the value updates in place instead of scrolling away. Interactive slider/number/toggle/button widgets flow back to the source (HTTP /control, or aidex_log control_set so the AI can tune a running program too). A button carries a press counter, not a flag, so a source polling at its own pace never misses a click. Full guide: docs/loghub-panel-dashboard.md.
The Controls group holds one of each interactive type: a slider, two toggles, and a button with its press counter beside it. Scrolled further down, several sources share the same dashboard — the hub knows nothing about what any value means, so a synth firmware and a demo script coexist without either being aware of the other:
The sliders react in real time — watch the GIF:
Close with aidex_viewer({ path: ".", action: "close" })
aidex scan Q:/develop # Find all indexed projects
aidex init ./myproject # Index a project from command line
aidex-mcpworks as an alias foraidex.
.aidex/ ← Created in YOUR project
├── index.db ← SQLite database
└── summary.md ← Optional documentation
AiDex/ ← This repository
├── src/
│ ├── commands/ ← Tool implementations
│ ├── db/ ← SQLite wrapper
│ ├── parser/ ← Tree-sitter integration
│ └── server/ ← MCP protocol handler
└── build/ ← Compiled output
GitHub Discussions — Ask questions, share your setup, suggest ideas.
See CONTRIBUTING.md for full details. Quick summary:
src/parser/languages/ and open a PRMIT License - see LICENSE
Uwe Chalas & Claude
MCP Server for persistent code indexing. Gives AI assistants (Claude, Gemini, Copilot, Cursor) instant access to your codebase. 50x less context than grep.
{ "mcpServers": { "cscsoftware-aidex": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}เครื่องมือ
ยังไม่มีรายการเครื่องมือ เซิร์ฟเวอร์แบบรีโมตจะได้รายการหลังการตรวจสอบสถานะครั้งแรก
FAQ
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
ระเบียนนี้ไม่ได้ระบุตัวแปรสภาพแวดล้อมที่จำเป็น
AiDex ทำงานแบบโลคัลผ่าน stdio
ตรวจสอบล่าสุดเมื่อ 2026-11-09 MCP Server for persistent code indexing. Gives AI assistants (Claude, Gemini, Copilot, Cursor) instant access to your codebase. 50x less context than grep.