No articles match your search.
Search
Find symbols using hybrid keyword + semantic matching.
Parameters
| Field | Description |
|---|
| terms | Keywords to match against symbol names, docstrings, and code |
| limit | Max results to return (default: 10) |
| lang | Filter by language: python, rust, typescript, etc. |
| package | Filter by top-level directory / package name |
| type | Filter by symbol type: function, method, class, constant, file |
Example
Search for validate → returns functions, methods, and classes whose name, docstring, or code contains "validate", ranked by relevance score (0–1).
Tips
- Combines keyword matching with semantic similarity when embeddings are available
- Click any result to jump to its full Context view
- For conceptual queries like "error handling middleware", try Semantic Search instead
Semantic Search
Search by meaning using code embeddings rather than exact names.
Parameters
| Field | Description |
|---|
| query | Natural language description of what you're looking for |
| limit | Max results to return (default: 10) |
Example
Query database connection pooling → finds functions related to connection pools even if they're named get_pool or acquire_conn.
Tips
- Requires semantic embeddings to be built (check Health for availability)
- Best when you know what code does but not what it's called
- Use keyword Search when you know the exact symbol name
Quick Lookup
Get full details on a symbol in a single step.
Parameters
| Field | Description |
|---|
| name | Symbol name to look up (e.g. function or class name) |
| full | Show complete source without truncation |
Example
Look up parse_config → returns source code, callers, callees, and related tests for the best-matching symbol, all in one response.
Tips
- Combines Search + Context into one step — fastest way to get a complete picture
- If the wrong match is found, use Search to pick the right one, then Context
Callers
Find every function or method that calls the given symbol.
Parameters
| Field | Description |
|---|
| name | Symbol name to find callers of |
| limit | Max callers to return (default: 20) |
Example
Callers of validate_token → shows every function that invokes validate_token, with file locations and call count.
Tips
- More reliable than grep — uses the call graph to distinguish real calls from comments and strings
- Essential before refactoring: know who depends on a function before changing its signature
- Click any caller to view its full Context
Callees
Find every function or method that the given symbol calls.
Parameters
| Field | Description |
|---|
| name | Symbol name to find callees of |
| limit | Max callees to return (default: 20) |
Example
Callees of handle_request → shows every function that handle_request invokes internally.
Tips
- Answers "what will break if this dependency changes?"
- Use Flow Trace for a recursive view (callees of callees of callees...)
Context
Complete dossier for a symbol: source, callers, callees, tests.
Parameters
| Field | Description |
|---|
| node_id | Full node ID (e.g. FILE:src/app.py::MyClass::init) |
| full | Show complete source without truncation |
| expand callees | Inline source of small callees directly in the output |
Example
Context for a function → shows its signature, docstring, full source code, list of callers, list of callees, and any test functions that reference it.
Tips
- Usually reached by clicking a result in Search, Callers, or other tools
- The node_id is the full graph identifier — you rarely need to type it manually
- "Expand callees" inlines the source of small helper functions so you can read them in place
Structure
Show the skeleton of a file: all symbols with line numbers.
Parameters
| Field | Description |
|---|
| filename | File path or partial filename to match (e.g. handlers.py) |
Example
Structure of server.py → lists imports, constants, classes, and functions defined in the file, with line numbers and types. Much faster than reading the full source.
Tips
- Great for orientation when entering an unfamiliar file
- Click any symbol to jump to its full Context
- Partial filenames work —
server matches web/server.py
Flatten
Show the full public API of a type including inherited methods.
Parameters
| Field | Description |
|---|
| class_node_id | Full node ID of the class/struct (e.g. FILE:src/app.py::MyClass) |
Example
Flatten HttpClient → shows all methods including those inherited from traits, interfaces, or parent classes, giving you the complete available API.
Tips
- Requires the full node ID — use Search or Structure to find it first
- Shows methods from all levels of the inheritance hierarchy
Implementations
Find all types that implement a trait or interface method.
Parameters
| Field | Description |
|---|
| method | Method name to find implementations of |
| trait_name | Optional: filter to a specific trait or interface |
Example
Impls of parse → shows every struct, class, or type that has a parse method, grouped by trait when applicable.
Tips
- Far more precise than grep for polymorphic code — filters out false positives
- Add a trait name to narrow results when a method name is common
Flow Trace
Visualize the recursive call tree from any symbol.
Parameters
| Field | Description |
|---|
| start | Symbol name to start tracing from |
| direction | forward (what it calls) or backward (what calls it) |
| depth | How many levels deep to trace (default: 3) |
| target | Optional: stop tracing when this symbol is reached |
Example
Flow forward from main, depth 3 → shows a tree of main → its callees → their callees → their callees. Small functions are inlined with source code.
Tips
- Forward = "what happens when this runs?" / Backward = "how do we get here?"
- Click any node in the tree to jump to its Context
- Set a target to focus the trace on a specific call path
- Use Call Path instead if you just need the shortest route between two symbols
Call Path
Find the shortest call chain between two symbols.
Parameters
| Field | Description |
|---|
| start | Source symbol name |
| end | Target symbol name |
| max_depth | Maximum hops to search (default: 10) |
Example
Path from handle_request to write_log → shows each hop with the call site code snippet: handle_request → process → write_log.
Tips
- More focused than Flow Trace, which shows the entire tree
- Useful for verifying that a specific code path exists
- If no path is found, the symbols may be in disconnected parts of the graph
Cross-Language
Trace API calls from frontend to backend via OpenAPI spec.
Parameters
| Field | Description |
|---|
| mode | endpoint (single route), list (all routes for a tag), or stats (coverage overview) |
| method | HTTP method: GET, POST, PUT, DELETE |
| path | API path (e.g. /api/v1/users) |
| tag | OpenAPI tag to filter by (for list mode) |
Example
Endpoint GET /api/v1/users → shows which backend handler function serves this route and which frontend functions call it.
Tips
- Requires an OpenAPI spec to be configured (see project config)
- Use "stats" mode first to see available endpoints and coverage
- Bridges the gap when tracing user actions from UI to backend
Churn
Find the most frequently changed code using git history.
Parameters
| Field | Description |
|---|
| mode | symbols (function-level), files (file-level), or co-change (coupled pairs) |
| time_range | Git time range, e.g. last 30 days, since 2024-01-01 |
| path_filter | Optional: limit to files matching a path prefix or pattern |
| limit | Max results (default: 20) |
Example
Churn in symbols mode, last 30 days → ranks functions by how many commits touched them. High-churn symbols may need refactoring or better test coverage.
Tips
co-change mode reveals hidden coupling: pairs of symbols that always change together- Filter by path to focus on a specific module or directory
- Use Evolution to drill into a specific high-churn symbol's history
Evolution
Track the commit history of a specific function or file.
Parameters
| Field | Description |
|---|
| name | Symbol or file name to track |
| time_range | Optional: limit to a time window |
| limit | Max commits to show (default: 10) |
| show_diff | Include actual code diffs at each commit |
Example
Evolution of parse_config with diffs → shows a timeline of commits, authors, dates, and the actual code changes at each point. Follows the function across renames.
Tips
- Uses git's native function tracking to follow symbols across line drift and renames
- Enable "Show diffs" to see what changed at each commit
- Great for understanding why a function looks the way it does
Changes
Analyze recent commits to see modified symbols and their callers.
Parameters
| Field | Description |
|---|
| commit_range | Git range, e.g. HEAD~5..HEAD, main..feature |
| time_range | Alternative: time-based range like last 7 days |
| path_filter | Optional: limit to files matching a pattern |
| show_callers | Include callers of changed functions (blast radius) |
Example
Changes in HEAD~5..HEAD with callers → shows which functions were modified in the last 5 commits, plus every function that calls them, revealing the full blast radius.
Tips
- The "show callers" option is what makes this powerful — it reveals ripple risk
- Use for code review: see at a glance what a PR touches and what depends on it
- Defaults to the last commit if no range is specified
Health
Check graph status, feature availability, and freshness.
Parameters
| Field | Description |
|---|
| No parameters — runs automatically |
Example
Health → shows node count, edge count, graph age, and which features are available (SCIP indexing, semantic embeddings, git history, cross-language tracing).
Tips
- Check this first if tools return unexpected results — the graph may be stale
- The status dot in the header gives a quick summary (green = fresh, yellow = stale)
Reindex
Rebuild the knowledge graph from scratch.
Parameters
| Field | Description |
|---|
| No parameters — rebuilds everything |
Example
Reindex → re-scans all source files, rebuilds the call graph, regenerates SCIP indices and semantic embeddings. Progress streams live to the output log.
Tips
- Run after significant code changes: new files, renames, refactoring
- May take several minutes for large codebases with SCIP enabled
- Progress is streamed live — watch the log for current step
Source
View source files with line numbers and optional line highlighting.
Parameters
| Field | Description |
|---|
| file | File path relative to project root |
| line | Optional: line number to highlight and scroll to |
Example
Source src/app.py line 42 → opens the file with line 42 highlighted. Useful for examining the surrounding code of a specific call site.
Tips
- Usually reached by clicking file locations in other tools
- Markdown files can be toggled between raw and rendered view
The Knowledge Graph
How descry models your codebase as nodes and edges.
Nodes
Every symbol in your code becomes a node: functions, methods, classes, constants, files, and configuration items. Each node has a unique ID like FILE:src/app.py::MyClass::init encoding its location in the file hierarchy.
Edges
Edges represent relationships: calls (function A calls function B), contains (file contains class), inherits (class extends parent), and imports. This structure enables tools like Callers, Callees, Flow Trace, and Call Path.
How It's Built
Descry parses source files using language-aware AST parsers for Python, Rust, TypeScript, Go, Svelte, and more. When SCIP indexing is available, cross-references are precise (compiler-level accuracy). The graph is cached as JSON and rebuilt on demand via Reindex.
Symbol Types
The badge system used throughout descry results.
Legend
FUNFunctionStandalone functions and arrow functions
METMethodMethods on a class, struct, or impl block
CLAClassClasses, structs, enums, traits, interfaces, protobuf messages
CONConstantExported constants and static values
FILFileSource files (.py, .rs, .ts, .svelte, .go, .proto, etc.)
CFGConfigurationInterceptors, middleware, and event handlers
Tips
- The Score (0–1) shown in search results combines keyword and semantic relevance
- Click any badge in results to view that symbol's full Context
- Use the type filter in Search to narrow results to a specific kind of symbol
SCIP Indexing
Compiler-level precision for cross-references and type resolution.
What is SCIP?
SCIP (Source Code Intelligence Protocol) is a standard for representing code intelligence data. Descry uses SCIP indices produced by language-specific indexers (rust-analyzer for Rust, scip-typescript for TypeScript) to resolve cross-references with compiler-level accuracy.
Why It Matters
Without SCIP, descry relies on AST-based name matching which can produce false positives (e.g., two functions with the same name in different modules). With SCIP, every reference is resolved to its exact definition — no ambiguity.
Supported Languages
Rust (via rust-analyzer), TypeScript/JavaScript (via scip-typescript). Check Health to see if SCIP is available for your project. SCIP is optional — all tools work without it, just with less precision.
Semantic Embeddings
How vector search finds conceptually similar code.
How It Works
Each symbol's name, docstring, and signature are converted into a high-dimensional vector using a code embedding model. When you search, your query is also embedded, and results are ranked by cosine similarity — how close two vectors point in the same direction.
When to Use
Semantic Search: when you know what code does but not its name. "rate limiting middleware" finds throttle_requests. Keyword Search: when you know the name. throttle_requests finds it directly.
Tips
- Embeddings are built during Reindex — check Health for availability
- The hybrid Search tool combines both approaches automatically
Git History Analysis
How descry uses git log for churn, evolution, and change impact.
Three Perspectives
Churn answers "what changes most?" by counting commits per symbol or file. Evolution answers "how did this change over time?" with a commit timeline. Changes answers "what did these commits affect?" with impact analysis.
How It Works
Descry maps git diff output back to the knowledge graph. Changed line ranges are resolved to their enclosing functions, giving you symbol-level granularity instead of just file-level diffs.
Tips
- Requires a git repository — check Health for availability
- Time ranges use git's natural language:
last 30 days, since 2024-01-01
Investigating a Function
Start with a name, expand outward to build full understanding.
Steps
1Quick Lookup the function name to get source, callers, callees, and tests in one shot.
2Context — click any related symbol to explore its details. Toggle "full" for complete source.
3Callers — understand who depends on this function and how it's used in practice.
4Flow Trace forward to see the full execution tree, or backward to see how control reaches this point.
When to Use
- Before modifying a function — understand its callers and dependencies first
- When debugging — trace the flow to find where things go wrong
- During code review — verify that changes don't break callers
Understanding a Codebase
Get the lay of the land when entering an unfamiliar project.
Steps
1Health — see how large the codebase is (node/edge counts) and what features are available.
2Structure on key files (e.g. main.py, app.rs) to see what's defined where.
3Search for entry points like main, handler, route to find where execution starts.
4Flow Trace forward from entry points to understand the main execution paths.
When to Use
- Onboarding onto a new project
- Returning to a codebase after a long break
- Evaluating an open-source library before adopting it
Tracking Recent Changes
See what's been happening in the codebase recently.
Steps
1Changes with HEAD~5..HEAD and "show callers" to see recent modifications and their blast radius.
2Churn in symbols mode to identify which functions are changing most frequently.
3Evolution on high-churn symbols to see their full change timeline and understand patterns.
When to Use
- Starting your workday — catch up on what teammates changed
- Before a release — assess the scope of recent changes
- Prioritizing refactoring — high-churn code benefits most from cleanup