Getting Started with LIP

LIP keeps a live, queryable code intelligence graph of your repository. This guide gets you from zero to a running daemon with editor and AI agent integration in about five minutes.

Prerequisites

• Rust 1.78+ — rustup update stable
• No other requirements — no system protoc, no running compiler

Install

cargo install lip-cli

Or from source:

git clone https://github.com/nyxCore-Systems/LIP
cd LIP
cargo install --path tools/lip-cli

Verify:

lip --version
# lip 1.3.0

Step 1 — Start the daemon

The daemon is the heart of LIP. It watches your files, maintains the query graph, and answers queries over a Unix socket.

lip daemon --socket /tmp/lip.sock

Leave this running in a terminal. On first start it indexes your repository with Tier 1 (tree-sitter, < 1 ms/file). From that point it watches each file individually and re-indexes only what changed.

You’ll see:

INFO  lip_daemon: journal replayed  entries=0
INFO  lip_daemon: listening         socket=/tmp/lip.sock

The daemon survives restarts — it replays its WAL journal on startup so the graph is immediately warm.

Step 2 — Index your project

In a second terminal, send your project to the daemon:

lip index ./src

Step 3 — Make your first queries

# Search for a symbol by name
lip query symbols "AuthService"

# Find the blast radius of a change
lip query blast-radius "lip://local/src/auth.rs#AuthService.verifyToken"

# Go to definition at line 42, column 10
lip query definition file:///path/to/src/auth.rs 42 10

# Blast radius returns risk level + direct/transitive dependents

Step 4 — Connect your editor (LSP)

LIP speaks standard LSP. Any editor that supports LSP works without a plugin.

lip lsp --socket /tmp/lip.sock

VS Code — add to .vscode/settings.json:

{
  "languageServerExample.serverCommand": "lip",
  "languageServerExample.serverArgs": ["lsp", "--socket", "/tmp/lip.sock"]
}

Neovim (with nvim-lspconfig):

require('lspconfig').lip.setup({
  cmd = { 'lip', 'lsp', '--socket', '/tmp/lip.sock' },
  filetypes = { 'rust', 'typescript', 'python', 'dart' },
})

Helix — add to languages.toml:

[[language]]
name = "rust"
language-servers = ["lip"]

[language-server.lip]
command = "lip"
args = ["lsp", "--socket", "/tmp/lip.sock"]

JetBrains IDEs — configure a custom language server pointing to lip lsp.

Step 5 — Connect an AI agent (MCP)

lip mcp --socket /tmp/lip.sock

Add to your MCP client config:

Claude Code (~/.claude/mcp.json):

{
  "mcpServers": {
    "lip": {
      "command": "lip",
      "args": ["mcp", "--socket", "/tmp/lip.sock"]
    }
  }
}

The agent gets access to lip_blast_radius, lip_workspace_symbols, lip_definition, lip_references, lip_hover, lip_dead_symbols, lip_annotation_get, lip_annotation_set, and 11 more tools.

See MCP Integration for the full tool reference.

Step 6 — Pre-build dependency slices (recommended)

The first time you run on a new machine, build slices for your dependencies so they never need to be re-indexed:

lip slice --cargo    # Rust deps from Cargo.toml
lip slice --npm      # Node deps from package.json
lip slice --pub      # Dart deps from pubspec.yaml
lip slice --pip      # Python pip-installed packages

# Build and share with your team
lip slice --cargo --push --registry https://registry.lip.dev

See Registry & Slices.

What’s running

After setup you have up to three processes:

The daemon is the only required process. The LSP bridge and MCP server connect to it on demand and can be started/stopped freely.

Next steps

• CLI Reference — every command and flag
• The Daemon — persistence, file watcher, service setup
• MCP Integration — AI agent workflows
• Embeddings & Semantic Search — semantic nearest-neighbour search