LABSCO SUMMARY

For structure questions; grep is still right for text.

The split is stated by the tool itself and worth keeping: definitions, callers and impact go here, while strings and config values are still a text search. The interface is unusual in a useful way — you send code rather than arguments, so a question like what does changing this break and who depends on that file runs as one call with both queries in parallel. Start by asking it to list its own methods; the API is discoverable from inside the tool, so there is nothing to memorise before the first real question.

What it is

Code intelligence as a query surface. A CLI parses your source locally and uploads only structural metadata — functions, classes, imports, calls, references — and the single tool runs queries against the graph built from it.

What you get

Symbol search across the codebase by name, as the entry point to almost every other question
A symbol's details, its dependents and its dependencies — the callers-and-callees questions that text search answers badly
Impact analysis for a symbol, which is the question actually being asked when someone says can I change this
Usage traced through the code from a symbol, rather than found by grepping for its name
Circular dependencies located, and orphaned code that nothing references identified
An architecture overview of the project as a whole
Several of these composed in one call, because the tool takes code rather than parameters — queries run together and return as one result
The API discoverable from inside the tool: a method listing with signatures, and inline TypeScript definitions for any one of them
Branch isolation, so each git branch carries its own code intelligence

Requirements

A Constellation account and an access key in CONSTELLATION_ACCESS_KEY — every request is authenticated. The MCP server runs as npx -y @constellationdev/mcp@latest, but it only answers about a project the Constellation CLI has already analysed: the CLI parses your code locally and uploads metadata, and the graph is what queries run against. So source code stays in your environment while structure does not — the relationships, names and references are held by the service. Node.js v24 or newer. AGPL-3.0.

Setup effort

Follow the published steps

See installation options

USE CASES

Working out what breaks if you change a function

Find the symbol, run impact analysis on it, and read what depends on the file it lives in — in one composed call.

code_intel

Finding every real caller of something

Trace usage through the graph instead of grepping for a name that also appears in comments, strings and unrelated files.

code_intel

Getting oriented in an unfamiliar repository

Ask for the architecture overview, then search for the symbols it names to see how the pieces connect.

code_intel

Cleaning up before a refactor

Locate circular dependencies and code that nothing references, so the delete list is derived rather than guessed.

code_intel

Learning what the query API can do

List the available methods with their signatures and pull the TypeScript types for the one you want, from inside the tool.

code_intel

1 tool

Counted once with only startup setup. Other versions, modes or optional credentials may expose a different list.

`code_intel`

DECISION RULE: Structure questions → this tool. Text search → Grep.

Before using Grep, ask: Is this a STRUCTURE question (definitions, callers, impact) or a TEXT question (strings, config)?

QUICK START: return await api.searchSymbols({query: "AuthService"}) — simple queries are one-liners. Run api.listMethods() for full API reference with signatures and descriptions. Run api.help("methodName") for inline TypeScript type definitions — no resource reads needed. Compose: const [impact, deps] = await Promise.all([api.impactAnalysis({symbolId}), api.getDependents({filePath})]);

WHY THIS TOOL: Graph-backed intelligence finds indirect relationships, transitive dependencies, and breaking change risks that text search cannot detect.

"What uses X?" disambiguation: getDependents (file imports) vs getCallGraph (call chain) vs traceSymbolUsage (all usages).

USE IMMEDIATELY WHEN:

BEFORE using Edit on a function/class → run impactAnalysis({symbolId}) first
BEFORE exploring an unfamiliar codebase → run getArchitectureOverview()
BEFORE refactoring → trace getDependencies + getDependents for blast radius
Running 3+ Grep calls for structure? STOP → use code_intel instead

TOP 5 QUESTIONS (query is case-insensitive substring match):

"Where is X defined?" / "Find function Y" → searchSymbols({query})
"What calls X?" / "What imports this?" → getDependents({filePath}) or getCallGraph({symbolId})
"What does X depend on?" → getDependencies({filePath})
"Safe to modify X?" / "Blast radius?" → impactAnalysis({symbolId})
"Find dead code" / "Unused exports?" → findOrphanedCode()
"Complex functions?" / "Refactoring targets?" → searchSymbols results include complexity.cyclomaticComplexity + complexityRisk per function

NOT FOR: literal string search, log messages, config values, or reading source code. Use Grep/Glob/Read for those. Supports TypeScript, JavaScript, Python, and more — run api.getCapabilities() to check your project. File-path-scoped methods (getDependencies, getDependents, getCallGraph, traceSymbolUsage, impactAnalysis) reject calls whose filePath extension is not in the project's configured languages with UNSUPPORTED_LANGUAGE — check api.getCapabilities() first.

WRONG TOOL SIGNAL: If you've run 3+ Grep calls for structure (callers, dependencies, impact), STOP and use code_intel instead. Typical workflow: code_intel to find (results include source snippets) → Edit to modify

Sandbox limits: 50 api.* calls per execution, 128 MB memory, 100 KB max code size, limit max 100 on any method with a limit param. Pure JS only — no require/import/fs/net/process (see constellation://docs/guide for full restrictions).

IMPORTANT: The cwd parameter is required — always set it to the target project directory path.

INSTALLATION

Connect your client

Server setup

Setup

Create a Constellation account and register your organization, create your project, and create an access key (https://docs.constellationdev.io/)

Install the Constellation CLI:

TERMINAL

npm install -g @constellationdev/cli@latest

Authenticate — this persists your credential on your local system:

TERMINAL

const auth

Initialize Constellation in your project; it prompts for the project ID, languages and the AI tools to configure: const init

Build the index — this parses your code locally and streams the metadata to the Constellation service; run it again to update: const index

npx

TERMINAL

npx -y @constellationdev/mcp@latest

MCP Clients

Any MCP client

ANY MCP CLIENT · JSON

{
  "mcpServers": {
    "constellation": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@constellationdev/mcp@latest"
      ],
      "env": {
        "CONSTELLATION_ACCESS_KEY": "${CONSTELLATION_ACCESS_KEY}"
      }
    }
  }
}

Clients that expand ${…} variables in their config (Claude Code does in .mcp.json) read the key from your environment. In a client that does not, the access key itself has to be written there.

Claude Code — Plugin

CLAUDE CODE — PLUGIN · JSON

{
  "extraKnownMarketplaces": {
    "constellation-plugins": {
      "source": {
        "source": "github",
        "repo": "ShiftinBits/constellation-claude"
      }
    }
  },
  "enabledPlugins": {
    "constellation@constellation-plugins": true
  }
}

Cursor

CURSOR · JSON

{
  "mcpServers": {
    "constellation": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@constellationdev/mcp@latest"
      ],
      "env": {
        "CONSTELLATION_ACCESS_KEY": "${env:CONSTELLATION_ACCESS_KEY}"
      }
    }
  }
}

GitHub Copilot CLI

GITHUB COPILOT CLI · TERMINAL

copilot plugin install ShiftinBits/constellation-copilot

Constellation

For structure questions; grep is still right for text.

What it is

What you get

Requirements

Setup effort

Working out what breaks if you change a function

Finding every real caller of something

Getting oriented in an unfamiliar repository

Cleaning up before a refactor

Learning what the query API can do

1 tool

`code_intel`

What to know first

Tools you get

Requires

Light Standing cost

Connect your client

Server setup

Setup

npx

MCP Clients

Any MCP client

Claude Code — Plugin

Cursor

GitHub Copilot CLI

Constellation

For structure questions; grep is still right for text.

What it is

What you get

Requirements

Setup effort

Working out what breaks if you change a function

Finding every real caller of something

Getting oriented in an unfamiliar repository

Cleaning up before a refactor

Learning what the query API can do

1 tool

code_intel

What to know first

Tools you get

Requires

Light Standing cost

Connect your client

Server setup

Setup

npx

MCP Clients

Any MCP client

Claude Code — Plugin

Cursor

GitHub Copilot CLI

Same category

Zig MCP

Open Kioku

CodeGraphContext

ChunkHound

`code_intel`