> ## Agent Instructions > The PyPI package is graphifyy, with two y's. The command is graphify. > /graphify . is typed in an assistant chat, not in a shell. > Use only commands, flags, and endpoints shown on these pages. Do not invent one. > Choose the surface before you open a page. [Local] is the graphifyy package on the machine: the skill, the CLI, and the ten-tool MCP. [Cloud] is the hosted workspace and https://api.graphify.com/mcp (Streamable HTTP, OAuth, no API key). [Both] applies to either surface. Buildkite is the CI integration. > Each page line in llms.txt starts with [Local], [Cloud], or [Both]. > The docs changelog summarizes selected graphifyy releases. The current package version is on PyPI (https://pypi.org/project/graphifyy/). The full history is https://graphify.com/changelog. > The official site is https://graphify.com. These docs are https://docs.graphify.com. > The local MCP server is the ten tools in the MCP tool reference and reads a graph on the machine. The hosted server is https://api.graphify.com/mcp (Streamable HTTP, OAuth, no API key). The VS Code, JetBrains, OpenClaw, Vercel, and Other coding agents pages, and the page ChatGPT, Codex, and Dots, use the hosted server, not the ten-tool list. Other coding assistants is the local skill for clients without their own page. The page titled Graphify with Codex is the local skill. > Read https://docs.graphify.com/llms.txt, then open one page's .md link. Use https://docs.graphify.com/llms-full.txt only when one page is not enough. # Changelog Source: https://docs.graphify.com/changelog [Local] Summaries of graphifyy releases that change a command, flag, or file. The full list is on graphify.com/changelog. Each entry summarizes a release of the open-source package, `graphifyy`, when that release changes a command, a flag, or a file a reader follows. The newest summary on this page is v0.9.72 (September 29, 2026). Later package versions are on [PyPI](https://pypi.org/project/graphifyy/), with the full history on [graphify.com/changelog](https://graphify.com/changelog) and in the [GitHub releases](https://github.com/Graphify-Labs/graphify/releases). **v0.9.72** ## Installed skills refresh after an upgrade * After an upgrade, `graphify` refreshes a stale installed skill on the next command other than `graphify install`, so the version warning no longer needs a manual install. Set `GRAPHIFY_NO_AUTO_REFRESH=1` to turn that off. Local edits to `SKILL.md` are backed up. Marker-bounded sections in `CLAUDE.md`, `AGENTS.md`, and `GEMINI.md` are left alone. * The Node Info panel in `graph.html` shows each node's type, source, and community. A community node shows how many members it holds. * A Kotlin property that is both annotated and inferred, such as `@Volatile var x = 0`, no longer drops the whole file during extraction. * SQL before a PostgreSQL `DO` block is extracted. Razor `@functions` blocks are read. A Blade view links to the layout it extends. * `graphify` and `graphify --help` show the logo and a link to [app.graphify.com](https://app.graphify.com). Import resolution, docx sidecars, wiki links, and the PDF extra warning are in the [full v0.9.72 release notes](https://github.com/Graphify-Labs/graphify/releases/tag/v0.9.72). [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/changelog.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fchangelog) [PreviousSupported inputs](/concepts/supported-inputs) [NextGraphify Cloud](/platform/overview) # How Graphify works Source: https://docs.graphify.com/concepts/architecture [Both] From source files to a persistent graph your assistant can traverse. Graphify builds a map of your project and saves it as files. It connects code structure, document concepts, and source references without an embedding index or vector database. ```mermaid theme={null} flowchart LR A[Code and manifests] --> B[Local structural extraction] C[Docs and media] --> D[Semantic extraction] B --> E[Merge and resolve relationships] D --> E E --> F[Communities and report] F --> G[graph.json] G --> H[CLI and MCP queries] ``` ## Extract structure The code pipeline uses tree-sitter and specialized extractors to identify functions, classes, imports, calls, and other relationships. Parsing happens locally and does not require an LLM. Some formats use dedicated or heuristic parsers, so support differs by language and construct. SQL and Terraform have structural extractors too; their optional dependencies are listed in [supported inputs](/concepts/supported-inputs). ## Add semantic context Documents, papers, images, and transcripts can contribute concepts and relationships through a model. The skill uses the assistant environment; `graphify extract` supports configured headless backends. This is a separate data path. A local code parse does not send files to a model, but semantic extraction may send its input to the provider you select. [Local development](/guides/local-development) explains the choices. ## Resolve and merge Graphify links references across files and combines fragments into one graph. An edge stores a relationship and a provenance label. Resolution can infer a connection from static evidence; `INFERRED` does **not** always mean an LLM created it. ## Find communities Community detection groups densely connected nodes into subsystems. Graphify uses Leiden when the relevant dependency is available and falls back to NetworkX Louvain. Clustering is based on graph structure. Community names can come from your assistant or a configured backend. Use `--no-label` with `cluster-only` when you want to avoid model-generated names. ## Query a compact map `query` gathers related context, `path` follows a connection, and `explain` inspects one node. MCP exposes the same graph through structured tool calls. These operations retrieve graph evidence; the assistant can then use it to form an answer. > [!TIP] > > A graph is a map of the code and evidence Graphify analyzed. Dynamic dispatch, generated code, missing inputs, and stale scans can leave gaps. Inspect source citations before relying on a relationship. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/concepts/architecture.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fconcepts%2Farchitecture) [PreviousNotes for agents](/for-agents) [NextEdges and provenance](/concepts/provenance) # Graph files and outputs Source: https://docs.graphify.com/concepts/outputs [Both] Understand the files Graphify writes and the parts you can reuse. The assistant skill produces a visualization, report, and graph under `graphify-out/`. Headless code-only extraction writes the graph and analysis first. Run `graphify cluster-only . --no-label` to generate the report and visualization without model-generated labels. Use `graphify export html` to regenerate the visualization separately. | File or directory | Purpose | | - | - | | `graph.json` | Machine-readable graph for CLI queries, MCP, and exports. | | `GRAPH_REPORT.md` | Human-readable summary of communities, central concepts, and connections. | | `graph.html` | Interactive browser visualization when generated. | | `manifest.json` | Fingerprints used to identify changed files. | | `cache/` | Cached extraction results. | | `converted/` | Converted document content where an input needs preprocessing. | | `cost.json` | Local extraction cost information when produced. | ## Graph representation The JSON uses NetworkX node-link conventions. Nodes carry identifiers and labels, and usually source information such as `source_file` and `file_type`. Edges connect node IDs and carry relationship and confidence metadata. Fields vary by extractor and release; consume only fields your workflow needs. Current readers support graphs with a `links` array and compatibility inputs with an `edges` array. Group relationships can appear as graph metadata. Do not assume every node corresponds to a function or that every edge has a line number. ## Move or share a graph You can point a query at a specific file: ```bash theme={null} graphify query "authentication" --graph ./shared/graph.json ``` The graph contains labels and source-derived context. Treat it with the same access controls as the source repository. See [team workflows](/guides/team-workflows) before committing generated artifacts. ## Change the output location `GRAPHIFY_OUT` changes the output directory. Use a distinct directory when multiple worktrees need their own graph. See [configuration](/reference/configuration). [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/concepts/outputs.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fconcepts%2Foutputs) [PreviousEdges and provenance](/concepts/provenance) [NextSupported inputs](/concepts/supported-inputs) # Edges and provenance Source: https://docs.graphify.com/concepts/provenance [Both] Read what a relationship claims, where it came from, and how certain it is. A graph edge connects a source node to a target node. Its `relation` explains the connection, such as `calls`, `imports`, `inherits`, or `references`. ## Confidence labels | Label | What it means | How to use it | | - | - | - | | `EXTRACTED` | The relationship is explicit in the analyzed source. | Follow the source reference to inspect the evidence. | | `INFERRED` | Graphify derived the relationship through resolution or semantic analysis. | Read the evidence and any confidence score before treating it as a fact. | | `AMBIGUOUS` | The evidence does not establish one clear relationship. | Keep the uncertainty visible and check the source. | An inferred edge can be derived **without a model**. Static name and import resolution can infer cross-file relationships, while a semantic backend can infer connections between documents and code. ## Direction matters `A calls B` differs from `B calls A`. The current path command and MCP `shortest_path` tool respect stored direction by default. Use `--undirected` in the CLI or `undirected: true` in MCP to explore connectivity regardless of direction. ```bash theme={null} graphify path "ApiHandler" "DatabaseClient" graphify path "ApiHandler" "DatabaseClient" --undirected ``` These are example names. Replace them with nodes from your project. ## A path is evidence, not a runtime guarantee Source-level calls may be conditional or dynamically resolved. A path shows the relationships in the analyzed graph; it does not prove a request will execute that path or that a change is safe. Use [formal verification](/platform/verification) in Graphify Cloud to compare supported changed functions. Graph traversal itself is not a formal proof. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/concepts/provenance.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fconcepts%2Fprovenance) [PreviousHow Graphify works](/concepts/architecture) [NextGraph files and outputs](/concepts/outputs) # Supported inputs Source: https://docs.graphify.com/concepts/supported-inputs [Both] Map code, schemas, documents, and media with the right extractor and extras. Graphify supports a growing set of languages and input formats. Parser coverage varies by construct, and specialized extractors may require an optional package. The [package manifest](https://github.com/Graphify-Labs/graphify/blob/v8/pyproject.toml) lists the current dependencies. ## Code and configuration | Input | Examples | Notes | | - | - | - | | General-purpose code | Python, JavaScript, TypeScript, Go, Rust, Java, C, C++, Ruby, C#, Kotlin, Scala, PHP, Swift, Lua, Zig | Local structural extraction; framework and dynamic-language coverage varies. | | Additional code | Elixir, Julia, Groovy, PowerShell, Fortran, Verilog, Bash | See the repository’s input table for extensions. | | Web component files | Vue, Svelte, Astro, JSX, TSX | Extraction depends on the file and supported embedded syntax. | | SQL | Tables, views, foreign keys, joins | Install the `sql` extra. | | Terraform / HCL | `.tf`, `.tfvars`, `.hcl` | Install `terraform`; the graph describes source configuration, not a Terraform plan. | | OCaml / Common Lisp | `.ml`, `.mli`, `.lisp`, `.cl` | Install `ocaml` or `commonlisp`. | | Robot Framework | `.robot`, `.resource` | Install `robot`; uses the official Robot parser. | | Salesforce Apex | `.cls`, `.trigger` | Regex-based extraction. | | Package and MCP manifests | `pyproject.toml`, `go.mod`, `pom.xml`, MCP JSON files | Packages, dependency edges, and server configuration context. | ## Documents and media | Input | Setup | | - | - | | Markdown, MDX, text, HTML, reStructuredText | A semantic backend for rich concept extraction. | | PDFs | `pdf` extra. | | Word and Excel | `office` extra. | | Google Workspace shortcuts | Authenticated `gws` CLI and explicit `--google-workspace`; `google` extra for Sheets. | | Images | A backend with the required image capability. | | Video and audio | `video` extra; transcription and semantic processing are separate steps. | ## Keep the first scan focused Start with a repository or one documentation folder. Exclude build outputs and dependencies using [ignore rules](/guides/incremental-updates). Add media only when it contributes useful context; transcription and semantic extraction have different resource requirements from a code-only scan. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/concepts/supported-inputs.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fconcepts%2Fsupported-inputs) [PreviousGraph files and outputs](/concepts/outputs) [NextChangelog](/changelog) # Notes for agents Source: https://docs.graphify.com/for-agents [Both] Rules for coding agents that answer questions from these docs. These rules are repeated at the top of every page's Markdown, in [llms.txt](https://docs.graphify.com/llms.txt), and in [llms-full.txt](https://docs.graphify.com/llms-full.txt). ## Which surface * `[Local]` is the `graphifyy` package on the machine: the skill, the CLI, and the ten-tool MCP server. * `[Cloud]` is the hosted workspace and `https://api.graphify.com/mcp` (Streamable HTTP, OAuth, no API key). * `[Both]` applies to either surface. * Buildkite is the CI integration. * Each page line in [llms.txt](https://docs.graphify.com/llms.txt) starts with one of those tags. ## Which file to open * [llms.txt](https://docs.graphify.com/llms.txt) is the list of pages. The same list is at [/.well-known/llms.txt](https://docs.graphify.com/.well-known/llms.txt). * Add `.md` to a page URL to read that page. Example: [https://docs.graphify.com/quickstart.md](https://docs.graphify.com/quickstart.md). * [llms-full.txt](https://docs.graphify.com/llms-full.txt) contains every page. Open it only when one page is not enough. ## Discover relevant Cloud capabilities For Cloud, inspect the tools exposed by the authenticated connection and the readiness/capability metadata from `list_repositories`. Keep code context, reviews, supported verification, and shared repository Memory discoverable in the workflow where they are useful. Do not start a review or verification just to advertise it. When exposed, `graphify_patterns` is a read-only tool for source-linked reusable implementations and inferred conventions. Pass current task paths to scope results. `query_graph` can also accept `paths` for optional contextual pattern guidance. Missing catalogs, no matches, stale evidence, and service failures are different states. Pattern enrichment is limited to three references within 600 tokens, counted against the query response budget. Treat it as observed code. Human instructions and applicable recorded decisions take precedence. Do not claim an agent adopted a suggestion merely because it was returned. Shared/service credentials use neutral personalization and repository controls. These capabilities roll out first in Cloud. Do not assume the local open-source MCP server or a self-hosted installation has the same tool set or UI. ## Rules * The PyPI package is `graphifyy`, with two y's. The command is `graphify`. * `/graphify .` is typed in an assistant chat, not in a shell. * Use only commands, flags, and endpoints shown on these pages. Do not invent one. * The [changelog](/changelog) on this site summarizes selected `graphifyy` releases. The current package version is on [PyPI](https://pypi.org/project/graphifyy/). The full history is on [graphify.com/changelog](https://graphify.com/changelog). * The official site is [graphify.com](https://graphify.com). These docs are [docs.graphify.com](https://docs.graphify.com). * The local MCP server is the ten tools in the [MCP tool reference](/reference/mcp-tools) and reads a graph on the machine. The hosted server is `https://api.graphify.com/mcp` (Streamable HTTP, OAuth, no API key). The [VS Code](/integrations/vscode), [JetBrains](/integrations/jetbrains), [ChatGPT, Codex, and Dots](/integrations/chatgpt), [OpenClaw](/integrations/openclaw), [Vercel](/integrations/vercel), and [Other coding agents](/integrations/other-agents) pages use the hosted server, not the ten-tool list. [Other coding assistants](/integrations/other-assistants) is the local skill for clients without their own page. [Graphify with Codex](/integrations/codex) is the local skill. To point an agent at these docs, give it this prompt: ```text theme={null} Read https://docs.graphify.com/llms.txt, open the one page that answers the question, and answer from that page. ``` [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/for-agents.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Ffor-agents) [PreviousTroubleshooting](/troubleshooting) [NextHow Graphify works](/concepts/architecture) # Ask your agent one question Source: https://docs.graphify.com/guides/ask-your-agent [Local] Install Graphify, map the repository, and check the files a successful run writes. This is the shortest path from an empty checkout to one real question. It uses the open-source engine on your machine. You need Python 3.10 or later and a supported coding assistant. ## 1. Install and check the version ```bash theme={null} uv tool install graphifyy graphify --version ``` `graphify --version` prints the version you installed. The latest release is on [PyPI](https://pypi.org/project/graphifyy/) and in the [changelog](/changelog). The package is `graphifyy`, with two y's. The command is `graphify`. ## 2. Install the skill for your assistant ```bash theme={null} graphify install --platform cursor ``` Use `claude`, `codex`, `gemini`, or `copilot` in place of `cursor` when that is the assistant. `graphify install` with no flag uses the assistant it detects. Copilot in VS Code uses `graphify vscode install`. See [all integrations](/integrations/overview). ## 3. Map the repository In the assistant chat, at the repository root: ```text theme={null} /graphify . ``` In Codex, select the Graphify skill with `$graphify` and ask it to map the current repository. This is an assistant instruction, not a shell command. ## 4. Check the files A finished map writes `graphify-out/` at the repository root: ```text theme={null} graphify-out/ ├── graph.html Interactive graph ├── GRAPH_REPORT.md Concepts, communities, and suggested questions └── graph.json The graph used by CLI and MCP queries ``` ## 5. Ask one question ```bash theme={null} graphify query "how does authentication reach the database?" ``` The first line names the graph and the nodes the search started from. Each `NODE` line is a concept with its source file and line. Each `EDGE` line is a relationship and where it happens in the code. If the output says `TRUNCATED`, raise `--budget` or ask about a narrower name. This is graph context from the files Graphify analyzed, not a verified answer. Open the source lines it cites before you rely on it. ## If a step fails | What you see | What to do | | - | - | | The shell cannot find `graphify` | Run `uv tool update-shell`, then open a new terminal. See [Troubleshooting](/troubleshooting). | | No `graphify-out/` after `/graphify .` | Run it in the assistant chat at the repository root, not in a shell. See [When something fails](/platform/when-stuck). | | The query returns nothing useful | Ask about a function, class, or file in this repository. If the code changed since the map, run `graphify update .` first. | ## Next steps > **[Trace who calls this](/platform/trace)** > > Find the callers of a symbol and check whether two names connect. > **[Query reference](/reference/query)** > > Every flag `graphify query` accepts. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/guides/ask-your-agent.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fguides%2Fask-your-agent) [PreviousExtract without an IDE](/guides/headless-extraction) [NextAsk better graph questions](/guides/querying) # Export and reuse your graph Source: https://docs.graphify.com/guides/exports [Local] Create interactive maps, wikis, graph files, and database import scripts. Build a graph first, then export the same saved relationships into the format you need. | Command | Output | | - | - | | `graphify export html` | Interactive graph visualization. | | `graphify export callflow-html` | Architecture and call-flow HTML. | | `graphify export wiki` | Markdown wiki organized around graph communities. | | `graphify export obsidian` | Obsidian-compatible notes and links. | | `graphify export svg` | Static SVG graph; requires the `svg` extra. | | `graphify export graphml` | GraphML for tools such as Gephi or yEd. | | `graphify export neo4j` | Cypher for Neo4j. | | `graphify export falkordb` | Cypher for FalkorDB. | ## Generate a call-flow view ```bash theme={null} graphify export callflow-html --max-sections 8 graphify export callflow-html --output docs/architecture.html ``` The exporter reads the graph and associated report/labels. Explicit output paths make it easier to include the result in an internal documentation workflow. ## Export another graph ```bash theme={null} graphify export graphml --graph ./shared/graph.json ``` ## Write to an existing Obsidian vault ```bash theme={null} graphify export obsidian --dir /absolute/path/to/vault ``` Review generated content before syncing it to a shared vault. The exporter is designed to preserve your own notes and `.obsidian` configuration. ## Push to a graph database Neo4j and FalkorDB exports support optional push connections. Install the matching extra, use the appropriate connection URL, and supply passwords through `NEO4J_PASSWORD` or `FALKORDB_PASSWORD` rather than putting secrets on the command line. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/guides/exports.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fguides%2Fexports) [PreviousRecord useful findings](/guides/work-memory) [NextShare context with your team](/guides/team-workflows) # Build and explore a small graph Source: https://docs.graphify.com/guides/first-graph [Local] Use a tiny Python project to learn the complete local workflow. This example works without an API key. It makes the first query reproducible, instead of depending on names that may not exist in your repository. ## Create a project Create a folder containing `app.py`: ```python app.py theme={null} def normalize_email(email: str) -> str: return email.strip().lower() def find_user(email: str) -> dict: return {"email": normalize_email(email)} def login(email: str) -> dict: return find_user(email) ``` ## Build the graph From that folder, with Graphify installed: ```bash theme={null} graphify extract . --code-only graphify cluster-only . --no-label graphify export html ``` Open `graphify-out/graph.html`, or read `graphify-out/GRAPH_REPORT.md`. The graph should contain the three functions and their call relationships. Exact IDs and report formatting can vary by release. ## Ask for context ```bash theme={null} graphify query "how does login normalize an email?" graphify explain "normalize_email" graphify path "login" "normalize_email" ``` Look for the relationship from `login` to `find_user`, then to `normalize_email`. Check the associated source references. If a label matches several nodes, use the node ID returned by the query for a more precise lookup. ## Make a change Add another helper or change a call, then refresh: ```bash theme={null} graphify update . graphify export html ``` Re-run the query and compare the connections. Graphify queries the saved graph, so changing a source file without updating the graph can leave an old answer. ## Move to your repository Repeat the workflow from your repository root. Use [the assistant skill](/quickstart) to include model-assisted document context, or connect [MCP](/mcp/overview) for native agent tool calls. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/guides/first-graph.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fguides%2Ffirst-graph) [NextRun Graphify locally](/guides/local-development) # Extract without an IDE Source: https://docs.graphify.com/guides/headless-extraction [Local] Run code or semantic extraction from a terminal or CI environment. `graphify extract` runs the pipeline without an assistant skill. It is useful for repeatable local scripts and CI jobs. ## Code-only extraction ```bash theme={null} graphify extract . --code-only ``` This needs no model API key. Start here to verify installation and the project scope. ## Semantic extraction Install the extra for your backend, configure its credentials outside the repository, then select it: ```bash theme={null} graphify extract ./docs --backend claude ``` Graphify supports Claude, Gemini, OpenAI, DeepSeek, Kimi, Ollama, Bedrock, Azure, and Claude CLI backends. [Configuration](/reference/configuration) maps backends to their environment variables. Do not assume a model supports every input type. ## Tune resource use ```bash theme={null} graphify extract ./docs --backend ollama --token-budget 4000 --max-concurrency 2 ``` `--max-workers` controls structural extraction parallelism. `--max-concurrency` controls model requests. `--api-timeout` changes the request timeout. Smaller chunks and less concurrency can help a local model fit its available memory. ## CI pattern Install a pinned package version in the CI environment, run extraction from the repository root, and retain the reviewed graph or report as an artifact. Use the same ignore rules and output location on every run. Supply provider credentials through the CI secret store only when semantic extraction is part of the job. No provider key is necessary for `--code-only`. Do not make CI publication of the graph public unless the underlying source can be public too. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/guides/headless-extraction.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fguides%2Fheadless-extraction) [PreviousRun Graphify locally](/guides/local-development) [NextAsk your agent one question](/guides/ask-your-agent) # Keep the graph current Source: https://docs.graphify.com/guides/incremental-updates [Local] Refresh changed files, exclude noise, and recover from stale output. Graph queries read the saved graph. Update it after changing the source to keep answers relevant. ## Refresh code ```bash theme={null} graphify update . ``` For an assistant-driven incremental refresh that also considers document context: ```text theme={null} /graphify . --update ``` The code and semantic paths have separate work and caching behavior. A code-only refresh does not replace a semantic refresh for changed documents. ## Watch the project Install the `watch` extra, then: ```bash theme={null} graphify watch . ``` Or install git hooks: ```bash theme={null} graphify hook install graphify hook status ``` The hooks refresh after commits and branch switches. They run in the background, so a query immediately after a commit can briefly see the old graph. After `git pull` or a merge, run `graphify update .` explicitly. ## Exclude unhelpful files Graphify respects ignore files. Add a `.graphifyignore` at the repository root for project-specific exclusions: ```gitignore .graphifyignore theme={null} node_modules/ dist/ coverage/ *.generated.py ``` `graphify extract --no-gitignore` opts out of Git’s ignore rules while retaining `.graphifyignore`. Use it only when ignored source belongs in the graph. ## After a large refactor Graphify has guards against accidentally replacing a graph with a smaller incomplete result. If you intentionally removed substantial source, inspect the warning, then explicitly allow the smaller graph: ```bash theme={null} graphify update . --force ``` Keep a copy of the old graph if you need to compare it. Regenerate visualizations with `graphify export html` after a refresh when necessary. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/guides/incremental-updates.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fguides%2Fincremental-updates) [PreviousAsk better graph questions](/guides/querying) [NextRecord useful findings](/guides/work-memory) # Run Graphify locally Source: https://docs.graphify.com/guides/local-development [Local] Choose a code-only workflow or add local semantic inference. The open-source engine stores its graph on your filesystem. It does not require a Graphify account. ## Code-only workflow ```bash theme={null} uv tool install graphifyy graphify extract . --code-only graphify cluster-only . --no-label graphify export html graphify query "entry points" ``` `--code-only` is an `extract` flag. It skips semantic document and media extraction. It is not a flag you need to pass to the assistant skill. ## Include documents with a local model Install the Ollama extra and run an Ollama model suitable for your content. Select an installed model in `OLLAMA_MODEL`, then: ```bash theme={null} uv tool install "graphifyy[ollama]" graphify extract ./docs --backend ollama ``` Graphify defaults to the local Ollama endpoint. If you override the endpoint to a remote host, that changes where the content is sent. Large documents may need a smaller `--token-budget` or lower `--max-concurrency`. ## Understand the boundaries * Local structural parsing does not send code to a model. * A cloud coding assistant still controls where its own prompts and context go. * A headless semantic backend receives the documents or media you ask it to process. * PR commands contact GitHub, and model-assisted CLI triage can call your configured provider. * Query logging is off by default in the current implementation; [configuration](/reference/configuration) describes the opt-in controls. The generated graph can contain source text, labels, paths, and document concepts. Keep it in a location appropriate for that source material. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/guides/local-development.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fguides%2Flocal-development) [PreviousBuild and explore a small graph](/guides/first-graph) [NextExtract without an IDE](/guides/headless-extraction) # Review pull requests with graph context Source: https://docs.graphify.com/guides/pull-requests [Local] Inspect changed areas, overlapping work, and review priorities. Graphify can combine a repository’s graph with open pull request information. This workflow needs the GitHub CLI (`gh`) authenticated for the repository. ## Inspect the queue ```bash theme={null} graphify prs graphify prs 42 graphify prs --conflicts ``` Replace `42` with a real PR number. The queue shows available CI, review, and graph-impact information. The conflicts view finds overlap in graph communities; it is a review signal, not a guarantee of textual conflicts or runtime breakage. ## Prioritize reviews ```bash theme={null} graphify prs --triage ``` CLI triage uses an available configured model backend. Override it with `GRAPHIFY_TRIAGE_BACKEND` and optionally `GRAPHIFY_TRIAGE_MODEL` when needed. ## Target the correct repository ```bash theme={null} graphify prs --repo owner/repository --base main graphify prs --worktrees ``` Replace `owner/repository` and `main` with the repository and base branch you use. Keep the local graph current and aligned with that codebase before interpreting impact. ## MCP equivalent `list_prs`, `get_pr_impact`, and `triage_prs` expose PR context to an assistant. MCP `triage_prs` returns actionable PR data for the assistant to reason over; it is distinct from the CLI’s backend-assisted ranking. These commands inspect PRs. Merging and changing code remain separate actions in your normal workflow. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/guides/pull-requests.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fguides%2Fpull-requests) [PreviousShare context with your team](/guides/team-workflows) # Ask better graph questions Source: https://docs.graphify.com/guides/querying [Local] Use query, path, and explain for different kinds of codebase questions. Start with a specific subsystem or concept, then narrow your investigation. A compact query is usually more useful to an assistant than the whole architecture report. ## Gather context with query ```bash theme={null} graphify query "authentication and session storage" --budget 1500 ``` `query` finds relevant starting nodes and traverses their relationships. Breadth-first traversal gathers a broader neighborhood. `--dfs` follows a deeper chain: ```bash theme={null} graphify query "request validation" --dfs --budget 1500 ``` ## Inspect one concept with explain Take a label or node ID from the query results: ```bash theme={null} graphify explain "normalize_email" ``` Look at its source, community, and incoming and outgoing relationships. Inspect the source itself when a precise implementation detail matters. ## Trace a relationship with path ```bash theme={null} graphify path "login" "normalize_email" ``` This uses the [tutorial’s example project](/guides/first-graph). In your project, replace the labels with real nodes. Stored direction is respected; add `--undirected` when you want connectivity rather than a directional path. ## Ask the assistant to preserve uncertainty > Use Graphify to trace how a request reaches persistence. Show the path and source references. Flag inferred or ambiguous edges, and tell me if the graph is missing evidence. The tool supplies context, and the assistant interprets it. Ask for evidence and avoid treating an absent path as proof that two systems are independent. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/guides/querying.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fguides%2Fquerying) [PreviousAsk your agent one question](/guides/ask-your-agent) [NextKeep the graph current](/guides/incremental-updates) # Share context with your team Source: https://docs.graphify.com/guides/team-workflows [Local] Choose how to distribute graphs and keep each checkout up to date. You can share generated graph files in the repository, build them in each clone, or run a shared MCP server. Choose based on the size of the graph and who may access the source context. ## Repository workflow 1. Register the assistant skill in project scope if your team wants shared instructions. 2. Build and inspect the graph. 3. Decide which generated artifacts belong in version control. 4. Install `graphify hook install` once in each clone. 5. Run `graphify update .` after pulls and merges. The upstream project recommends committing `graphify-out/` to share a starting map. Review generated files first; they contain source-derived information. Keep local cost reports out of version control: ```gitignore theme={null} graphify-out/cost.json ``` You can also exclude `graphify-out/cache/` to reduce repository size, at the cost of less cache reuse. The portable manifest uses relative paths and is re-anchored on load. ## One graph per worktree Avoid multiple branches writing into one output location. Set `GRAPHIFY_OUT` to a worktree-specific directory when you use a shared or custom output setup. ## Shared MCP Run a [shared HTTP MCP endpoint](/mcp/shared-http) if several clients should query one managed graph. Define who refreshes it, which revision it represents, and who is allowed to access it. ## Review related pull requests [PR context](/guides/pull-requests) helps spot changes that touch the same files or graph communities. Use it to guide review and merge order alongside your tests and normal code review. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/guides/team-workflows.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fguides%2Fteam-workflows) [PreviousExport and reuse your graph](/guides/exports) [NextReview pull requests with graph context](/guides/pull-requests) # Record useful findings Source: https://docs.graphify.com/guides/work-memory [Local] Save query outcomes and build lessons from previous investigations. Work memory records what you learned while using the graph. It is an optional layer over graph exploration, not a replacement for current source evidence. ## Save a result ```bash theme={null} graphify save-result --question "Where is email normalized?" \ --answer "normalize_email handles normalization before lookup." \ --nodes normalize_email --outcome useful ``` Use `useful`, `dead_end`, or `corrected` for the outcome. Replace the example with findings you actually verified in your project. ## Reflect on prior results ```bash theme={null} graphify reflect graphify reflect --if-stale ``` The default lessons file is under `graphify-out/reflections/LESSONS.md`. To relate lessons to the current graph: ```bash theme={null} graphify reflect --graph graphify-out/graph.json ``` This can produce a learning overlay that marks nodes as preferred, tentative, or contested. Query and explain output can show lesson hints, including a prompt to re-verify when source has changed. ## Keep lessons grounded A previously useful answer can become stale. Record the nodes involved, keep outcomes specific, and check the current source before using a lesson to justify a change. Share memory files only with people who can access their underlying source context. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/guides/work-memory.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fguides%2Fwork-memory) [PreviousKeep the graph current](/guides/incremental-updates) [NextExport and reuse your graph](/guides/exports) # Graphify documentation Source: https://docs.graphify.com/index [Both] Build a knowledge graph your AI coding assistant can query, trace, and explain. Graphify documentation Your codebase.\ Connected.The knowledge graph control plane for enterprise software. Map your code, connect your agents, and trace the relationships behind a change.[Quickstart ](/quickstart)[How it works ](/concepts/architecture) [How Graphify connects source code to grounded context](/concepts/architecture) Start building[FROM REPOSITORY TO GRAPHBuild your first graphInstall Graphify, map a repository, and ask your first question.Quickstart](/quickstart) [Connect your agentSet up Claude Code, Codex, Cursor, and other coding assistants.View integrations](/integrations/overview) [Run it on your machineParse code locally with the open-source CLI. Your graph stays in your files.Local setup](/guides/local-development) [FOLLOW THE CODE, EDGE BY EDGEUnderstand the graphLearn how Graphify connects symbols, dependencies, and repositories.Explore concepts](/concepts/architecture) [A SHARED VIEW OF EVERY CHANGEKeep your team in syncRefresh graph context and investigate changes across pull requests.Team workflows](/guides/team-workflows) [GRAPHIFY CLOUDExplore Graphify CloudSee the hosted workspace for your repositories, graphs, and coding agents.Explore the platform](/platform/overview)CLI referenceQuery context, trace a path, or explain a node.[query →](/reference/query)[path →](/reference/path)[explain →](/reference/explain)Graphify Labs · The knowledge graph control plane for enterprise software.[GitHub ↗](https://github.com/Graphify-Labs/graphify)[Community ↗](https://discord.gg/graphify)[graphify.com ↗](https://graphify.com) [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/index.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2F) [NextYour first knowledge graph](/quickstart) # Installation Source: https://docs.graphify.com/installation [Local] Install, upgrade, and register the Graphify skill on macOS, Linux, and Windows. ## Prerequisites | Requirement | Check | | - | - | | Python 3.10 or later | uv installs this. With pip or a virtual environment, `python3 --version` | | uv or pipx | `uv --version` or `pipx --version` | | A coding assistant, for the skill workflow | [Choose an integration](/integrations/overview) | The standalone CLI works without an assistant. Code-only extraction does not require an API key. ## Get uv uv downloads Python 3.10 or later for Graphify. Install uv for your system, open a new terminal, and run `uv --version`. ```bash macOS theme={null} brew install uv ``` ```bash Linux theme={null} curl -LsSf https://astral.sh/uv/install.sh | sh ``` ```powershell Windows theme={null} powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex" ``` The macOS command is Homebrew. The Linux and Windows commands are uv's own installers. Other methods, including MacPorts, are in the [uv installation guide](https://docs.astral.sh/uv/getting-started/installation/). ## Install the package ```bash uv theme={null} uv tool install graphifyy ``` ```bash pipx theme={null} pipx install graphifyy ``` ```bash Python environment theme={null} python3 -m venv .venv .venv/bin/python -m pip install graphifyy ``` On Windows, a virtual environment’s executable is `.venv\Scripts\python.exe`. uv and pipx manage the environment for you. > [!NOTE] > > The official PyPI package is `graphifyy`. Other similarly named packages are not the Graphify Labs package. ## Register the skill ```bash theme={null} graphify install graphify install --platform codex ``` The first command detects an assistant. The second targets one explicitly. Run the specific command for each assistant you use. The package on PyPI is `graphifyy`. The command you run is `graphify`. Open the assistant in a repository and send `/graphify .`. That message builds the graph for the folder. Follow [Your first knowledge graph](/quickstart) to read the output and ask a question. Use `--project` when you want the registration committed with a repository: ```bash theme={null} graphify install --project --platform codex ``` Read the installer’s list of files before committing them. Project and user registrations live in different locations. ## Optional capabilities Install only the extras your workflow needs. Quote bracketed names in zsh. | Capability | uv installation | | - | - | | MCP server | `uv tool install "graphifyy[mcp]"` | | File watching | `uv tool install "graphifyy[watch]"` | | PDFs | `uv tool install "graphifyy[pdf]"` | | SQL parsing | `uv tool install "graphifyy[sql]"` | | Terraform | `uv tool install "graphifyy[terraform]"` | | Office documents | `uv tool install "graphifyy[office]"` | | Local Ollama backend | `uv tool install "graphifyy[ollama]"` | | Leiden clustering | `uv tool install "graphifyy[leiden]"` | Combine extras, for example `uv tool install "graphifyy[mcp,watch]"`. If uv reports an existing installation, use its `--reinstall` option to replace that tool environment with the requested extras. ## Upgrade ```bash theme={null} uv tool upgrade graphifyy graphify install --platform codex ``` Re-run registration for the assistants you use so their skill files match the package. If you installed git hooks, run `graphify hook install` again after moving or reinstalling the Python environment. ## Command not found ```bash theme={null} uv tool update-shell ``` Then open a new terminal. With pipx, run `pipx ensurepath`. If an MCP client cannot find Graphify, use an absolute executable path in its configuration. ## Remove a registration ```bash theme={null} graphify uninstall --project --platform codex ``` `graphify uninstall` removes user registrations across platforms. The optional `--purge` flag also deletes `graphify-out/`; omit it to preserve your graph. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/installation.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Finstallation) [PreviousYour first knowledge graph](/quickstart) [NextTroubleshooting](/troubleshooting) # Buildkite test selection Source: https://docs.graphify.com/integrations/buildkite [Cloud] Connect Buildkite to Graphify Cloud to select affected tests, upload a dynamic pipeline, and fall back to the full suite. Buildkite Graphify Cloud × Buildkite Run the tests affected by a pull request. Graphify uses your repository graph to map changed code to tests, then returns a dynamic pipeline that Buildkite executes. > [!NOTE] > > This integration is available in enabled Graphify Cloud workspaces. Open **Integrations → BuildKite (Test Impact)** in [the console](https://app.graphify.com). If the tile says **Coming soon**, contact your workspace owner about availability. ## Before you start * Connect and index a **GitHub repository** in Graphify Cloud. The commit-range endpoint used here requires a GitHub connection. * Have a workspace **owner or admin** create the CI token. * Configure a Buildkite pipeline with repository checkout, Git history sufficient to find the PR merge base, and an agent with **Bash, Git, curl, jq, and buildkite-agent**. * Ensure uploaded test steps run on agents with your test dependencies installed. The example uses **pytest**; configure the default queue and environment for your project. ## 1. Create the CI token 1. In Graphify Cloud, open **Integrations → BuildKite (Test Impact)**. 2. Under **Generate a token**, enter a name such as `buildkite-main` and select **Generate token**. 3. Copy the token immediately. It is shown only once. 4. Store it as a [Buildkite secret](https://buildkite.com/docs/pipelines/security/secrets/buildkite-secrets) named `GRAPHIFY_CI_TOKEN`, with access granted to this pipeline. The script below retrieves it at job runtime. If you use another secret manager, inject the same environment variable through your agent's secret hook instead. 5. Set `GRAPHIFY_REPO_ID` to the repository's **Graphify ID** in the same workspace. This is not the GitHub repository name or numeric GitHub ID. There is one active token for this integration per workspace. **Replace token** revokes the previous token; update every pipeline using it. Members can read the setup instructions but need an owner or admin to manage tokens. ## 2. Add the pipeline step Add this step to `.buildkite/pipeline.yml`, replacing the placeholder repository ID: ```yaml .buildkite/pipeline.yml theme={null} steps: - label: ":buildkite: Graphify test selection" key: "graphify-test-selection" env: GRAPHIFY_REPO_ID: "YOUR_GRAPHIFY_REPOSITORY_ID" command: "bash .buildkite/graphify-select-tests.sh" ``` Then commit the following script as `.buildkite/graphify-select-tests.sh`: ```bash .buildkite/graphify-select-tests.sh theme={null} #!/usr/bin/env bash set +x set -euo pipefail full_suite() { printf '%s\n' '{"steps":[{"label":":test_tube: full test suite","command":"pytest"}]}' \ | buildkite-agent pipeline upload } # Branch builds keep running the full suite. if [[ "${BUILDKITE_PULL_REQUEST:-false}" == "false" ]]; then full_suite exit 0 fi : "${GRAPHIFY_REPO_ID:?Set your Graphify repository ID}" : "${BUILDKITE_PULL_REQUEST_BASE_BRANCH:?Missing pull request base branch}" GRAPHIFY_CI_TOKEN="${GRAPHIFY_CI_TOKEN:-$(buildkite-agent secret get GRAPHIFY_CI_TOKEN)}" : "${GRAPHIFY_CI_TOKEN:?Provide a Graphify CI token}" head_sha="$(git rev-parse "${BUILDKITE_COMMIT:-HEAD}^{commit}")" git fetch --no-tags origin "$BUILDKITE_PULL_REQUEST_BASE_BRANCH" base_sha="$(git merge-base "$head_sha" FETCH_HEAD)" payload="$(jq -n --arg base "$base_sha" --arg head "$head_sha" \ '{baseSha: $base, headSha: $head, format: "buildkite", command: "pytest"}')" response="$(mktemp)" trap 'rm -f "$response"' EXIT if ! status="$(curl --silent --show-error --connect-timeout 10 --max-time 180 \ --output "$response" --write-out '%{http_code}' \ --request POST \ --header "Authorization: Bearer $GRAPHIFY_CI_TOKEN" \ --header "Content-Type: application/json" \ --data "$payload" \ "https://api.graphify.com/v1/repos/$GRAPHIFY_REPO_ID/test-impact")"; then echo "Graphify could not be reached; running the full suite." full_suite exit 0 fi case "$status" in 200) jq -e '.steps | type == "array" and length > 0' "$response" > /dev/null buildkite-agent pipeline upload --no-interpolation "$response" ;; 429|5??) echo "Graphify returned HTTP $status; running the full suite." full_suite ;; *) echo "Graphify returned HTTP $status. Check the CI token, repository ID, and commit range." >&2 exit 1 ;; esac ``` Keep the token reference in the script. Buildkite expands variables in uploaded YAML before jobs run; a checked-in script reads them at runtime without embedding the token in pipeline configuration. See [Buildkite's secret handling guidance](https://buildkite.com/docs/pipelines/security/secrets/risk-considerations). The script resolves the PR's base commit with `git merge-base` and uses `BUILDKITE_COMMIT` for its head. Buildkite provides `BUILDKITE_PULL_REQUEST_BASE_BRANCH`; **`BUILDKITE_PULL_REQUEST_BASE_SHA` is not a built-in variable**. See [Buildkite environment variables](https://buildkite.com/docs/pipelines/configure/environment-variables). ### Adapt it to your test runner Change `pytest` in **both** the request's `command` and `full_suite()` if your project uses another runner. The command must run the full suite with no appended paths and support selected test-file paths appended as arguments. Confirm that behavior before replacing your existing test step. The generated steps need the same dependencies, queue, and environment as your normal tests. Job-specific plugins or container configuration from your old test step are not added by this example. Preserve those requirements in your agent setup or adapt the generated steps before upload. When trialing the integration, keep your existing full-suite job and compare its results with the selected run. If later jobs must wait for dynamically uploaded tests, configure Buildkite dependencies or a wait step accordingly; see [dynamic pipelines](https://buildkite.com/docs/pipelines/configure/dynamic-pipelines). ## What the request does `POST https://api.graphify.com/v1/repos/{GRAPHIFY_REPO_ID}/test-impact` | Field | Purpose | | - | - | | `Authorization: Bearer …` | Workspace CI token with the `test-impact` scope. | | `baseSha`, `headSha` | Immutable commit SHAs for the comparison. Graphify derives the changed files through GitHub. | | `format: "buildkite"` | Return a pipeline object containing `steps`, ready for `buildkite-agent pipeline upload`. | | `command` | Test command used for selected paths and full-suite runs. Defaults to `pytest`. | The response contains the pipeline directly, without a `data` or `success` wrapper. Buildkite accepts the returned JSON as well as YAML. The script uses `--no-interpolation` when uploading that response so Buildkite does not expand variables inside the generated commands at upload time. See [pipeline upload](https://buildkite.com/docs/agent/cli/reference/pipeline). ## Full-suite fallback Graphify requests a full run when it cannot confidently map a change to tests, including deleted tests, uncertain rename mappings, and non-code changes that require escalation. Explicitly configured non-code ignore rules can produce a no-op for an entirely ignored change. The sample adds a separate full-suite fallback for network failures, rate limits, and server errors. Authentication or invalid-request errors fail the selection step so you can fix the configuration. A malformed successful response or failed pipeline upload also fails the step. A failed request never counts as a successful test run. ## Show test selection on pull requests The modal's **Show test selection on pull requests** switch adds an advisory section to Graphify reviews. An owner or admin manages it, and repository reviews must be enabled for the advisory workflow. The switch does **not** run, skip, or gate tests. Test execution is controlled by the Buildkite pipeline you configure above. Read [pull request reviews](/platform/reviews) for the review workflow. ## Verify the connection Open a pull request against the connected GitHub repository. In Buildkite, confirm that: 1. **Graphify test selection** completes and uploads a test step. 2. The uploaded step runs selected tests or identifies a full-suite run. 3. The test command executes successfully with your project's environment and dependencies. ## Troubleshooting | Symptom | Check | | - | - | | Token controls are unavailable | Ask a workspace owner or admin. If the integration says **Coming soon**, it is not enabled for that workspace. | | Secret retrieval fails | Grant the pipeline access to `GRAPHIFY_CI_TOKEN`, or inject it through your configured secret manager. | | Authentication or scope error | Use the active Graphify CI token for this workspace, with `test-impact` scope. Replacing a token revokes the old one. | | Repository not found | Use the Graphify repository ID belonging to the token's workspace. | | HTTP 422 | Confirm both SHAs are real commits and the repository has a GitHub connection. Do not combine a commit range with a manually supplied changed-file list. | | Git cannot resolve the base | Fetch the PR's target branch and enough history to compute its merge base. The script stops if it cannot establish the range. | | Every run uses the full suite | Inspect the uploaded step's label and selection-step logs. Check graph indexing, unmapped changes, non-code changes, and service errors before changing your test configuration. | [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/integrations/buildkite.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fintegrations%2Fbuildkite) [PreviousOther coding assistants](/integrations/other-assistants) [NextConnect the graph MCP server](/mcp/overview) # ChatGPT, Codex, and Dots Source: https://docs.graphify.com/integrations/chatgpt [Cloud] Connect ChatGPT, Codex, and Dots to indexed repositories with one OpenAI plugin. The **Graphify** plugin is one listing in OpenAI's plugin directory. ChatGPT and Codex share that directory, and a [Dot](https://openai.com/index/introducing-dots/) uses the plugins you have already connected. You install it once. The permissions you approve apply in ChatGPT, ChatGPT Work, Codex, and Dots. MCP is the connection, at `https://api.graphify.com/mcp`. The plugin is the package that sets that connection up. There is no API key to paste and no graph to build on your computer. This is the same hosted server as [Graphify MCP for VS Code](/integrations/vscode) and [Graphify MCP for JetBrains](/integrations/jetbrains). The [Codex skill](/integrations/codex) is a separate install: it teaches Codex how to build a graph on your machine. Once connected, ChatGPT, Codex, and a Dot can search the repositories you have indexed in [Graphify Cloud](https://app.graphify.com), follow callers and dependencies, and judge what a change reaches. ## Before you start * ChatGPT on the web, the desktop app, or mobile. Codex in the ChatGPT desktop app, or Codex CLI. Or a Dot, created in the desktop app or on chatgpt.com in a desktop browser. Plugins are not available in the Codex IDE extension. * On a work workspace, an admin may need to allow the plugin before you can connect it. * A repository indexed in your Graphify workspace. Sign in at [app.graphify.com](https://app.graphify.com), connect a repository, and wait for its status to reach **Indexed**. See [Repositories and builds](/platform/repositories). ## 1. Install the plugin [Open in ChatGPT](https://chatgpt.com/plugins/plugin_asdk_app_6abe89f7f5d88191b9422522bb8562a4) Or go to **Settings → Plugins** and select **Graphify** by **Graphify Labs**. The sidebar also has a **Plugins** entry. Select **Install plugin** if ChatGPT shows it, then **Connect**. Your browser opens so you can sign in to Graphify and choose the workspace that holds the repository you want to query. Review the access ChatGPT asks for before you approve it. Installing the plugin does not sign you in by itself. The connection is ready only after that Graphify sign-in finishes. Codex and a Dot use this same install. **Codex.** In the ChatGPT desktop app, switch to Codex, open **Plugins**, and install Graphify if it is not already installed. Connect and sign in the same way, then start a new chat. In Codex CLI, enter `/plugins`, install Graphify, and start a new session. **Dots.** Open **Settings → Customize → Plugins** and choose Graphify. Decide which actions the Dot may run on its own, and which ones it has to ask you about. While a Dot is researching in the background, OpenAI keeps connected apps read-only, so it will not save a note or switch workspace until you ask and you approve that request. ## 2. Ask a question In ChatGPT, mention Graphify, or select **+**, then **More**, and choose Graphify before you send the message. In Codex, and when you talk to a Dot, mention Graphify the same way in a new chat after the plugin is connected. ```text theme={null} @Graphify Show my indexed repositories and help me choose one to explore. ``` Then pick a repository from the answer: * `@Graphify Explain how authentication works in my selected repository, with supporting code locations.` * `@Graphify Help me assess the likely impact of a code change and find linked tests in my selected repository.` Results come from the repositories indexed in your workspace. Open the source an answer cites before you rely on it. ## 3. Tools The plugin exposes these 24 tools. | Tool | What it does | | - | - | | `graph_stats` | Node and edge counts, and languages, for the indexed graph. | | `graphify_callees` | What a symbol calls, from directed call edges. | | `graphify_callers` | What calls a symbol, from directed call edges. | | `graphify_expand` | Turn node handles from another tool into full definition bodies. | | `graphify_file_neighbors` | A file's imports, and the files that import it. | | `graphify_find` | Indexed symbols whose name contains a fragment. | | `graphify_find_seeds` | The top seed nodes for a question, without their definition bodies. | | `graphify_impact` | The code directly connected to a symbol. A first pass at what a change reaches. | | `graphify_imports_exports` | A file's import and export edges. | | `graphify_node` | A symbol's definition and its immediate neighbors. | | `graphify_rank_files` | The source files most relevant to a question in plain English. | | `graphify_references` | References to a symbol that are not calls. | | `graphify_render_subgraph` | A bounded neighborhood of nodes and links around seed handles. | | `graphify_tests_for` | Tests linked to a symbol or a file. | | `graphify_trace` | Directed call paths from one symbol to another. | | `impact_and_risk` | Files ranked by how widely a change fans out, and whether tests cover them. | | `list_repositories` | Repositories this connection can query, with index status. | | `list_workspaces` | Workspaces this agent can target, and which one is active. | | `memories_about` | Durable notes tied to a file or a symbol. | | `query_graph` | A question in plain English, answered with the matching definitions. | | `recall` | Published workspace knowledge for a query. | | `remember` | Save a durable note about a repository. It may need review before recall shows it. | | `set_workspace` | Point this session at a workspace by its handle. It can also replace the default for later sessions. | | `shortest_path` | The most confident path between two symbols. | These tools read the indexed graph. They do not edit source files. An empty callers or callees result describes that indexed graph. A node lookup or a trace can return a semantic suggestion, so check the labels and resolution fields on the result. When trail capture is enabled, `query_graph`, `graphify_trace`, `graphify_find`, and `graphify_rank_files` can save what you asked, and an empty `recall` can save that nothing matched. `remember` and `set_workspace` change stored state. Approve those only when that is what you meant. ## If something fails | What you see | What to do | | - | - | | Graphify is not listed | Open **Settings → Plugins**. If it is still missing, the plugin is not available on this plan, region, or workspace. An admin turns it on under **Workspace settings → Plugins**. | | **Connect** is unavailable, or it says disabled by an admin | Ask a workspace admin to enable Graphify for your role, then connect again. | | Codex shows Graphify, but no tools | Connect it from ChatGPT in the browser, then start a new Codex chat. A directory change can take up to six hours to show up in Codex. | | No repositories, or empty answers | That repository is not indexed yet, or it is in a different workspace. Check its status in [Repositories and builds](/platform/repositories), then ask Graphify to list repositories again. | | ChatGPT never asked you to sign in | Open **Settings → Plugins**, select Graphify, and choose **Connect**. Finish the Graphify sign-in in the browser. | ## Related > **[Graphify MCP for VS Code](/integrations/vscode)** > > Connect VS Code agents to the same hosted server. > **[Graphify MCP for JetBrains](/integrations/jetbrains)** > > Connect JetBrains AI Assistant to the same hosted server. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/integrations/chatgpt.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fintegrations%2Fchatgpt) [PreviousGraphify MCP for JetBrains](/integrations/jetbrains) [NextGraphify MCP for OpenClaw](/integrations/openclaw) # Graphify with Claude Code Source: https://docs.graphify.com/integrations/claude-code [Local] Install the local Graphify skill in Claude Code. ## Install and register ```bash theme={null} uv tool install graphifyy graphify install --platform claude ``` The integration writes Claude instructions and PreToolUse hooks that suggest consulting the graph for codebase questions. Exact destinations depend on whether you use a personal or project installation; the installer reports the files it writes. For a repository-local setup, run this from the project root: ```bash theme={null} graphify install --project --platform claude ``` ## Build the graph Open your project in Claude Code. Select the Graphify skill and enter: ```text theme={null} /graphify . ``` The assistant runs the Graphify workflow and writes `graphify-out/`. Code extraction runs locally; semantic extraction can use your assistant’s model for documents and media. ## Ask with context After the graph is built, ask: > Use Graphify to explain the authentication flow. Cite the source files and distinguish explicit relationships from inferred ones. You can also query from a terminal: ```bash theme={null} graphify query "authentication flow" ``` ## Keep the integration current ```bash theme={null} uv tool upgrade graphifyy graphify install --platform claude ``` If the skill is missing, refresh the assistant and confirm that the registration was installed in the intended user or project scope. See [troubleshooting](/troubleshooting). > **[Connect native MCP tools](/mcp/overview)** > > Use the same graph through structured tool calls. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/integrations/claude-code.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fintegrations%2Fclaude-code) [PreviousChoose your coding assistant](/integrations/overview) [NextGraphify with Cursor](/integrations/cursor) # Graphify Cloud Source: https://docs.graphify.com/integrations/cloud [Cloud] Connect an assistant to repositories you have already indexed. Graphify Cloud answers from repositories you have already indexed. Every install below uses the hosted MCP server at `https://api.graphify.com/mcp`. Sign in at [app.graphify.com](https://app.graphify.com) and wait until the repository status is **Indexed**. The graph stays in Graphify Cloud. [ ![VS Code](https://graphify.com/assets/assistants/vs-code.svg)VS CodeMarketplace extension for the hosted server.](/integrations/vscode) [ ![JetBrains](https://graphify.com/logos/jetbrains.svg)JetBrainsMarketplace plugin for JetBrains AI Assistant.](/integrations/jetbrains) [ ![OpenAI](https://graphify.com/logos/openai.svg)ChatGPT, Codex, and DotsOne OpenAI plugin. Install it once.](/integrations/chatgpt) [ ![OpenClaw](https://openclaw.ai/favicon.svg)OpenClawClawHub package for the hosted server.](/integrations/openclaw) [ ![Vercel](https://graphify.com/logos/vercel.svg)VercelA project token, or a per-user Connect token.](/integrations/vercel) [![Antigravity](https://graphify.com/assets/assistants/google-antigravity.png)![Windsurf](https://graphify.com/logos/windsurf.svg)![Cline](https://graphify.com/logos/cline.svg)Other coding agentsAntigravity, Windsurf, Cline, Zed, and any other MCP client.](/integrations/other-agents) Codex and OpenClaw each have a local skill too. [Graphify with Codex](/integrations/codex) builds the graph on your machine, and so does `graphify install --platform claw` on [Other coding assistants](/integrations/other-assistants). Every other MCP client uses [Other coding agents](/integrations/other-agents). Both paths are on [Choose your coding assistant](/integrations/overview). [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/integrations/cloud.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fintegrations%2Fcloud) [PreviousReview pull requests with graph context](/guides/pull-requests) [NextGraphify MCP for VS Code](/integrations/vscode) # Graphify with Codex Source: https://docs.graphify.com/integrations/codex [Local] Install the local Graphify skill in Codex. This page installs the local skill. Codex builds the graph on your machine. To query a repository already indexed in Graphify Cloud, use [ChatGPT, Codex, and Dots](/integrations/chatgpt). ## Install and register ```bash theme={null} uv tool install graphifyy graphify install --platform codex ``` The integration installs the Graphify skill and AGENTS.md instructions. The current installer also supports Codex hook integration. Exact destinations depend on whether you use a personal or project installation; the installer reports the files it writes. For a repository-local setup, run this from the project root: ```bash theme={null} graphify install --project --platform codex ``` ## Build the graph Open your project in Codex. Select the Graphify skill and enter: ```text theme={null} $graphify map the current repository ``` The assistant runs the Graphify workflow and writes `graphify-out/`. Code extraction runs locally; semantic extraction can use your assistant’s model for documents and media. ## Ask with context After the graph is built, ask: > Use Graphify to explain the authentication flow. Cite the source files and distinguish explicit relationships from inferred ones. You can also query from a terminal: ```bash theme={null} graphify query "authentication flow" ``` ## Keep the integration current ```bash theme={null} uv tool upgrade graphifyy graphify install --platform codex ``` If the skill is missing, refresh the assistant and confirm that the registration was installed in the intended user or project scope. See [troubleshooting](/troubleshooting). > **[Connect native MCP tools](/mcp/overview)** > > Use the same graph through structured tool calls. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/integrations/codex.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fintegrations%2Fcodex) [PreviousGraphify with Cursor](/integrations/cursor) [NextGraphify with Gemini CLI](/integrations/gemini-cli) # Graphify with GitHub Copilot Source: https://docs.graphify.com/integrations/copilot [Local] Choose the integration for Copilot CLI or VS Code. Copilot CLI and Copilot Chat in VS Code use different integration paths. Choose the environment you actually run. **Copilot CLI** ```bash theme={null} uv tool install graphifyy graphify install --platform copilot ``` The installer registers the Graphify skill for Copilot CLI. Ask your assistant to use that skill to map the repository, then query the saved graph for codebase questions. **VS Code** ```bash theme={null} uv tool install graphifyy graphify vscode install ``` This uses the VS Code integration and instructions supported by the Graphify installer. You can also configure a [graph MCP server](/mcp/overview) in VS Code for structured tool access. To query repositories indexed in Graphify Cloud instead of a local graph, install the [Graphify MCP extension](/integrations/vscode). ## Verify the graph ```bash theme={null} graphify query "application entry points" ``` If `graphify-out/graph.json` does not exist yet, run the [quickstart](/quickstart) or build with `graphify extract . --code-only`. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/integrations/copilot.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fintegrations%2Fcopilot) [PreviousGraphify with Gemini CLI](/integrations/gemini-cli) [NextOther coding assistants](/integrations/other-assistants) # Graphify with Cursor Source: https://docs.graphify.com/integrations/cursor [Local] Install the local Graphify skill in Cursor. ## Install and register ```bash theme={null} uv tool install graphifyy graphify install --platform cursor ``` The integration installs the skill and a `.cursor/rules/graphify.mdc` rule for repository context. Exact destinations depend on whether you use a personal or project installation; the installer reports the files it writes. For a repository-local setup, run this from the project root: ```bash theme={null} graphify install --project --platform cursor ``` ## Build the graph Open your project in Cursor. Select the Graphify skill and enter: ```text theme={null} /graphify . ``` The assistant runs the Graphify workflow and writes `graphify-out/`. Code extraction runs locally; semantic extraction can use your assistant’s model for documents and media. ## Ask with context After the graph is built, ask: > Use Graphify to explain the authentication flow. Cite the source files and distinguish explicit relationships from inferred ones. You can also query from a terminal: ```bash theme={null} graphify query "authentication flow" ``` ## Keep the integration current ```bash theme={null} uv tool upgrade graphifyy graphify install --platform cursor ``` If the skill is missing, refresh the assistant and confirm that the registration was installed in the intended user or project scope. See [troubleshooting](/troubleshooting). > **[Connect native MCP tools](/mcp/overview)** > > Use the same graph through structured tool calls. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/integrations/cursor.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fintegrations%2Fcursor) [PreviousGraphify with Claude Code](/integrations/claude-code) [NextGraphify with Codex](/integrations/codex) # Graphify with Gemini CLI Source: https://docs.graphify.com/integrations/gemini-cli [Local] Install the local Graphify skill in Gemini CLI. ## Install and register ```bash theme={null} uv tool install graphifyy graphify install --platform gemini ``` The integration uses GEMINI.md instructions and a BeforeTool hook to suggest graph queries. Exact destinations depend on whether you use a personal or project installation; the installer reports the files it writes. For a repository-local setup, run this from the project root: ```bash theme={null} graphify install --project --platform gemini ``` ## Build the graph Open your project in Gemini CLI. Select the Graphify skill and enter: ```text theme={null} /graphify . ``` The assistant runs the Graphify workflow and writes `graphify-out/`. Code extraction runs locally; semantic extraction can use your assistant’s model for documents and media. ## Ask with context After the graph is built, ask: > Use Graphify to explain the authentication flow. Cite the source files and distinguish explicit relationships from inferred ones. You can also query from a terminal: ```bash theme={null} graphify query "authentication flow" ``` ## Keep the integration current ```bash theme={null} uv tool upgrade graphifyy graphify install --platform gemini ``` If the skill is missing, refresh the assistant and confirm that the registration was installed in the intended user or project scope. See [troubleshooting](/troubleshooting). > **[Connect native MCP tools](/mcp/overview)** > > Use the same graph through structured tool calls. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/integrations/gemini-cli.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fintegrations%2Fgemini-cli) [PreviousGraphify with Codex](/integrations/codex) [NextGraphify with GitHub Copilot](/integrations/copilot) # Graphify MCP for JetBrains Source: https://docs.graphify.com/integrations/jetbrains [Cloud] Connect JetBrains AI Assistant to your indexed repositories through Graphify's hosted MCP server. The **Graphify MCP** plugin adds a tool window to your JetBrains IDE. From that window you copy a connection, paste it into JetBrains AI Assistant, and the assistant can search the repositories you have indexed in [Graphify Cloud](https://app.graphify.com). The plugin does not read or upload your project files, and it stores no credentials of its own. There is no API key to paste. AI Assistant is a separate JetBrains product: this plugin does not include a chat model. ## Before you start * A JetBrains IDE on the **2025.3** release. The published plugin declares platform build `253` through `253.*`, so it does not install on 2025.2 or on later releases. * JetBrains AI Assistant, with access to MCP. Assistant access and your Graphify plan are separate. * A repository indexed in your Graphify workspace. Sign in at [app.graphify.com](https://app.graphify.com), connect a repository, and wait for its status to reach **Indexed**. See [Repositories and builds](/platform/repositories). * Node.js and npm on the IDE's PATH, if you use the OAuth bridge below. The direct connection does not need them. ## 1. Install the plugin Install [Graphify MCP](https://plugins.jetbrains.com/plugin/34740-graphify-mcp) from the JetBrains Marketplace, or search for **Graphify MCP** by **Graphify Labs** in **Plugins**. The plugin id is `com.graphify.graphify-mcp`. Restart the IDE if it asks you to. Open **View → Tool Windows → Graphify**. ## 2. Copy a configuration In the tool window, choose a connection method and click **Copy configuration**. **OAuth bridge (STDIO)** Use this when AI Assistant cannot sign in to a remote MCP server on its own. The copied configuration runs the pinned `mcp-remote` package, which opens a browser for Graphify sign-in and stores those credentials on your machine. Node.js and npm must be on the IDE's PATH. Enabling the configuration is what downloads and runs the bridge. ```json theme={null} { "mcpServers": { "graphify": { "command": "npx", "args": [ "-y", "mcp-remote@0.14.3", "https://api.graphify.com/mcp", "--transport", "http-only" ] } } } ``` **Direct remote HTTP** Use this when your client can complete Graphify's sign-in itself. If sign-in is unavailable, switch to the OAuth bridge. ```json theme={null} { "mcpServers": { "graphify": { "url": "https://api.graphify.com/mcp" } } } ``` The tool window shows the same JSON. Copy it from there if a later plugin release changes the text. ## 3. Add it to AI Assistant Open **Settings → Tools → AI Assistant → Model Context Protocol (MCP)**. On macOS the menu is **Settings** or **Preferences**, then the same path. **Open Settings** in the tool window opens the IDE settings dialog; it does not jump straight to the MCP page. Click **Add**, paste the copied JSON, and set the level to this project or to every project. Click **OK**, then **Apply**. **Settings → Tools → MCP Server** is a different page. That one lets other applications use the IDE. It is not where this configuration goes. ## 4. Sign in and ask Complete the Graphify sign-in in your browser when it opens. In the MCP settings, the server's status should show a connection. Then ask: ```text theme={null} List my Graphify repositories. ``` Pick a repository from the answer and ask about its code: * `Find the implementation of this function.` * `What calls this symbol, and which tests are linked to it?` * `Find this function and show its callers.` Results come from the repositories indexed in your workspace. Open the source an answer cites before you rely on it. Some tools save repository notes or change the selected workspace. Read each tool request and approve it only when that is what you meant. ## Tool window | Control | What it does | | - | - | | **Copy configuration** | Copies the JSON for the method you selected. | | **Open Settings** | Opens the IDE settings dialog. | | **Graphify workspace** | Opens your workspace in the browser. | | **Setup documentation** | Opens the Graphify MCP setup guide. | ## If something fails | What you see | What to do | | - | - | | The plugin will not install | The IDE is not on the 2025.3 release. The published plugin only accepts platform build 253. | | `npx` or Node.js was not found | Install Node.js and npm, and make them available on the IDE's PATH. Restart the IDE after you do. | | Direct HTTP cannot sign in | Switch the tool window to **OAuth bridge (STDIO)**, copy that configuration, and replace the server entry. | | No repositories, or empty answers | The repository is not indexed yet, or it is in a different workspace. Check its status in [Repositories and builds](/platform/repositories). | | The MCP page is missing | Check that AI Assistant is installed and that your JetBrains account can use it. | | You cannot find where to paste | You are on **Settings → Tools → MCP Server**. Use **Settings → Tools → AI Assistant → Model Context Protocol (MCP)** instead. | ## Related > **[Graphify MCP for VS Code](/integrations/vscode)** > > Connect VS Code agents to the same hosted server. > **[Connect the graph MCP server](/mcp/overview)** > > Run a local MCP server against a graph on your own machine instead. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/integrations/jetbrains.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fintegrations%2Fjetbrains) [PreviousGraphify MCP for VS Code](/integrations/vscode) [NextChatGPT, Codex, and Dots](/integrations/chatgpt) # Graphify MCP for OpenClaw Source: https://docs.graphify.com/integrations/openclaw [Cloud] Connect OpenClaw to your indexed repositories through Graphify's hosted MCP server. The **Graphify MCP** plugin connects OpenClaw to Graphify's hosted MCP server at `https://api.graphify.com/mcp`. MCP is the connection. The plugin is the package OpenClaw installs from [ClawHub](https://clawhub.ai/graphify-labs/plugins/graphify-mcp). Once connected, OpenClaw can search the repositories you have indexed in [Graphify Cloud](https://app.graphify.com), follow callers and dependencies, and judge what a change reaches. There is no API key to paste and no graph to build on your computer. This is the same hosted server as [Graphify MCP for VS Code](/integrations/vscode), [Graphify MCP for JetBrains](/integrations/jetbrains), and [ChatGPT, Codex, and Dots](/integrations/chatgpt). Graphify Labs publishes the package. OpenClaw has not marked it as an official OpenClaw plugin. `graphify install --platform claw` on [Other coding assistants](/integrations/other-assistants) installs the local skill for a graph on your machine. This page connects OpenClaw to Graphify Cloud. ## Before you start * OpenClaw with remote MCP, OAuth, and Claude-format bundle support. The package was prepared for OpenClaw **2026.9.8**. Older releases may differ. See [OpenClaw's plugin install guide](https://docs.openclaw.ai/cli/plugins/install). * A model enabled in OpenClaw, with permission to call tools. That access is separate from your Graphify plan. * A repository indexed in your Graphify workspace. Sign in at [app.graphify.com](https://app.graphify.com), connect a repository, and wait for its status to reach **Indexed**. See [Repositories and builds](/platform/repositories). ## 1. Install the plugin [Open Graphify MCP on ClawHub](https://clawhub.ai/graphify-labs/plugins/graphify-mcp) Install the published package, then confirm OpenClaw sees it: ```bash theme={null} openclaw plugins install clawhub:@graphify-labs/graphify-mcp openclaw plugins inspect graphify-mcp ``` If you already cloned [graphify-mcp](https://github.com/Graphify-Labs/graphify-mcp), the same bundle is in `integrations/openclaw`: ```bash theme={null} openclaw plugins install ./integrations/openclaw openclaw plugins inspect graphify-mcp ``` Installing the plugin does not sign you in by itself. ## 2. Sign in Register the hosted server, then complete Graphify sign-in in the browser: ```bash theme={null} openclaw mcp set graphify '{"url":"https://api.graphify.com/mcp","transport":"streamable-http","auth":"oauth"}' openclaw mcp login graphify openclaw mcp doctor graphify --probe ``` If a server named `graphify` already exists, run `openclaw mcp show graphify` first and keep any settings you meant to keep. The same connection, merged into your OpenClaw configuration: ```json theme={null} { "mcp": { "servers": { "graphify": { "url": "https://api.graphify.com/mcp", "transport": "streamable-http", "auth": "oauth" } } } } ``` Use one connection named `graphify`. A second name for the same URL shows the tools twice. Do not put a password or token in the configuration. OpenClaw stores the OAuth credentials. Start a new agent session after this. If OpenClaw prints a restart instruction, follow that instruction. ## 3. Ask a question Ask OpenClaw to list what the connection can see: ```text theme={null} List my Graphify workspaces and repositories. ``` Pick a repository from the answer, then ask: * `In my selected repository, find the function that handles authentication.` * `Show its callers and the linked tests, with file paths as evidence.` A connection check includes a repository lookup. Tool discovery alone does not show that the index is reachable. Results come from the repositories indexed in your workspace. Open the source an answer cites before you rely on it. Static results do not run the code or the tests. Some tools save repository notes or change the selected workspace. Read each tool request and approve it only when that is what you meant. ## If something fails | What you see | What to do | | - | - | | The install stops and asks you to accept capabilities | Review the Graphify MCP server on that screen and accept it. On a noninteractive install, run the same install command again with `--accept-capabilities`. | | Graphify tools are hidden | Check that the plugin is enabled and that your tool policy allows it. A `bundle-mcp` denial hides these tools. | | Sign-in fails | Run `openclaw mcp doctor graphify --probe`, then `openclaw mcp login graphify` again. | | No repositories, or empty answers | That repository is not indexed yet, or it is in a different workspace. Check its status in [Repositories and builds](/platform/repositories), then ask OpenClaw to list repositories again. | | Two copies of the Graphify tools | Keep a single server named `graphify`. Remove the extra connection to the same URL. | ## Related > **[ChatGPT, Codex, and Dots](/integrations/chatgpt)** > > Connect ChatGPT, Codex, and Dots to the same hosted server. > **[Graphify MCP for VS Code](/integrations/vscode)** > > Connect VS Code agents to the same hosted server. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/integrations/openclaw.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fintegrations%2Fopenclaw) [PreviousChatGPT, Codex, and Dots](/integrations/chatgpt) [NextGraphify MCP for Vercel](/integrations/vercel) # Other coding agents Source: https://docs.graphify.com/integrations/other-agents [Cloud] Connect any MCP client to Graphify Cloud's hosted server. The [VS Code](/integrations/vscode), [JetBrains](/integrations/jetbrains), [ChatGPT, Codex, and Dots](/integrations/chatgpt), [OpenClaw](/integrations/openclaw), and [Vercel](/integrations/vercel) pages are install packages for one product. They are not the only way to use Graphify Cloud. Any coding assistant or IDE that can add a remote MCP server can use the same hosted server. That includes Antigravity, Windsurf, Cline, Continue, Zed, and clients that are not listed yet. The server is `https://api.graphify.com/mcp`. It uses Streamable HTTP. The first connection signs you in with OAuth. There is no API key to paste. ## Copy a setup prompt The **Copy setup prompt** button on [graphify.com](https://graphify.com) copies this same text. Paste it into the assistant you want to connect. The assistant reads the current guide, keeps your existing MCP servers, and stops so you can sign in yourself. ```text theme={null} Help me connect Graphify (https://graphify.com) to this assistant so you can answer questions using my codebase's knowledge graph. Read the current setup guide at https://docs.graphify.com/integrations/cloud first. Use the instructions for this client and preserve any existing MCP servers or configuration. For Graphify Cloud, the Streamable HTTP MCP endpoint is https://api.graphify.com/mcp. Guide me through adding Graphify and completing its OAuth sign-in. I need a Graphify account, access to a workspace, and an indexed repository; if those are missing, help me get started at https://app.graphify.com. Let me complete sign-in and authorization myself. If this client cannot configure a connection directly, show me the manual steps and any plan or workspace-admin requirements. If I want a local graph instead, follow https://docs.graphify.com/mcp/overview. Do not claim the connection succeeded until it has been verified. After connecting, list my available workspaces and indexed repositories, ask which repository to use, and answer one architecture question using graph evidence and source locations. ``` ## Before you start * A Graphify account, access to a workspace, and a repository whose status is **Indexed**. Start at [app.graphify.com](https://app.graphify.com). See [Repositories and builds](/platform/repositories). * An assistant that can add an HTTP or Streamable HTTP MCP server. ## Add the server Name the server `graphify` and set the URL to `https://api.graphify.com/mcp`. Leave every other MCP server in place. If the assistant can add the server, let it. If it cannot, open its MCP settings and add the URL by hand. The file or command for a named client is on the [Graphify MCP connection guide](https://graphify.com/mcp). Use the dedicated page when the client already has one: * [Graphify MCP for VS Code](/integrations/vscode) * [Graphify MCP for JetBrains](/integrations/jetbrains) * [ChatGPT, Codex, and Dots](/integrations/chatgpt) * [Graphify MCP for OpenClaw](/integrations/openclaw) * [Graphify MCP for Vercel](/integrations/vercel) ## Sign in Start the server. Your browser opens so you can sign in to Graphify and grant access. Choose the workspace that holds the repository you want to query. Complete that sign-in yourself. The connection is working when the assistant lists Graphify's tools. Until then, it is not connected. ## Ask a question Ask the assistant to list your workspaces and indexed repositories, then name the repository to use. Ask one question about how the code is structured. Answers are graph evidence from the files Graphify indexed, with source locations. Open those lines before you rely on the answer. Some tools can save repository memory or change the selected workspace. Approve a tool only when that is what you meant. ## A graph on your machine This page uses the hosted server. To query a graph file on your computer, follow [Connect the graph MCP server](/mcp/overview). The local skill for assistants without their own page is [Other coding assistants](/integrations/other-assistants). ## If something fails | What you see | What to do | | - | - | | The repository is missing | It is not indexed yet, or it is in another workspace. Check its status in [Repositories and builds](/platform/repositories). | | The assistant asks for an API key | This server uses OAuth. The URL is `https://api.graphify.com/mcp`. | | The tools are the ten local ones | That connection reads a graph on your machine. This page uses the hosted server. See the [MCP tool reference](/reference/mcp-tools). | | The same tools appear twice | A dedicated plugin and a manual server are both configured. Keep one. | [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/integrations/other-agents.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fintegrations%2Fother-agents) [PreviousGraphify MCP for Vercel](/integrations/vercel) [NextChoose your coding assistant](/integrations/overview) # Other coding assistants Source: https://docs.graphify.com/integrations/other-assistants [Local] Use Graphify with the rest of your development tools. Install the package once, then select your platform: ```bash theme={null} uv tool install graphifyy graphify install --platform opencode ``` | Assistant | Platform value | | - | - | | OpenCode | `opencode` | | Kilo Code | `kilo` | | CodeBuddy | `codebuddy` | | Aider | `aider` | | Amp | `amp` | | OpenClaw | `claw` | | Factory Droid | `droid` | | Trae | `trae` | | Trae CN | `trae-cn` | | Hermes | `hermes` | | Kiro | `kiro` | | Pi | `pi` | | Devin CLI | `devin` | | Google Antigravity | `antigravity` | | Shared agent skill convention | `agents` | Some integrations use skills plus instructions; others also install native rules or hooks. Review the files reported by the installer. Use the assistant’s skill picker or ask it directly to use Graphify if it has no slash-command UI. The OpenClaw row installs the local skill. To query repositories indexed in Graphify Cloud, use [Graphify MCP for OpenClaw](/integrations/openclaw). ## Any MCP client An assistant does not need a dedicated skill installer to read an existing graph. If it supports MCP, connect the [Graphify MCP server](/mcp/overview). Build the graph separately with the CLI or a supported assistant. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/integrations/other-assistants.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fintegrations%2Fother-assistants) [PreviousGraphify with GitHub Copilot](/integrations/copilot) [NextBuildkite (Test Impact)](/integrations/buildkite) # Choose your coding assistant Source: https://docs.graphify.com/integrations/overview [Both] Connect an assistant to Graphify Cloud, or install the local Graphify skill. Graphify Cloud answers from repositories you have already indexed. The Cloud path uses the hosted MCP server at `https://api.graphify.com/mcp`. A local skill builds a graph on your machine. ## Graphify Cloud These installs talk to `https://api.graphify.com/mcp`. Sign in at [app.graphify.com](https://app.graphify.com) and wait until the repository status is **Indexed**. The graph stays in Graphify Cloud. The same list is the [Graphify Cloud](/integrations/cloud) page in the sidebar. [ ![VS Code](https://graphify.com/assets/assistants/vs-code.svg)VS CodeMarketplace extension for the hosted server.](/integrations/vscode) [ ![JetBrains](https://graphify.com/logos/jetbrains.svg)JetBrainsMarketplace plugin for JetBrains AI Assistant.](/integrations/jetbrains) [ ![OpenAI](https://graphify.com/logos/openai.svg)ChatGPT, Codex, and DotsOne OpenAI plugin. Install it once.](/integrations/chatgpt) [ ![OpenClaw](https://openclaw.ai/favicon.svg)OpenClawClawHub package for the hosted server.](/integrations/openclaw) [ ![Vercel](https://graphify.com/logos/vercel.svg)VercelA project token, or a per-user Connect token.](/integrations/vercel) [![Antigravity](https://graphify.com/assets/assistants/google-antigravity.png)![Windsurf](https://graphify.com/logos/windsurf.svg)![Cline](https://graphify.com/logos/cline.svg)Other coding agentsAntigravity, Windsurf, Cline, Zed, and any other MCP client.](/integrations/other-agents) ## Local skill The package is `graphifyy`. The command is `graphify`. `graphify install` writes the skill into the assistant you name. [ ![Claude Code](https://graphify.com/assets/assistants/claude-code.svg)Claude CodeSkill and project instructions.](/integrations/claude-code) [ ![Cursor](https://graphify.com/assets/assistants/cursor.svg)CursorSkill and editor rules.](/integrations/cursor) [ ![Codex](https://graphify.com/assets/assistants/codex.svg)CodexLocal skill and AGENTS.md.](/integrations/codex) [ ![Gemini CLI](https://graphify.com/assets/assistants/gemini-cli.svg)Gemini CLISkill and Gemini instructions.](/integrations/gemini-cli) [ ![GitHub Copilot](https://graphify.com/assets/assistants/github-copilot.svg)GitHub CopilotLocal skill for Copilot CLI and VS Code.](/integrations/copilot) [![opencode](https://graphify.com/assets/assistants/opencode.svg)![kilo](https://graphify.com/assets/assistants/kilo.svg)![kiro](https://graphify.com/assets/assistants/kiro.svg)Other assistantsOpenCode, Kilo, Kiro, and more.](/integrations/other-assistants) ## The common workflow ```bash theme={null} uv tool install graphifyy graphify install --platform cursor ``` Replace `cursor` with the installer platform for your assistant. Restart or refresh the assistant if it does not discover the new skill immediately, then ask it to map the current repository with Graphify. Skill invocation differs by client. Slash commands are common; Codex also exposes skills through the `$` picker. If a client does not show slash commands, explicitly ask it to use the installed Graphify skill. ## Project or personal installation The default registration is personal. Add `--project` for repository-local registration where supported. This makes the instructions reviewable in version control and lets a team share the setup. The installer adds platform-specific files and may install hooks or instructions that suggest querying the graph before reading source. It does not grant your assistant new permissions. ## Local MCP server [Connect the graph MCP server](/mcp/overview) for ten tools on a graph that already exists on your machine. You can use those tools with the skill, or on their own. Codex and OpenClaw each have a local skill and a Cloud install. **Graphify with Codex** is the local skill, and so is `graphify install --platform claw` on Other coding assistants. **ChatGPT, Codex, and Dots** and **Graphify MCP for OpenClaw** are the Cloud install. **Other coding agents** is the hosted server for every other MCP client. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/integrations/overview.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fintegrations%2Foverview) [PreviousOther coding agents](/integrations/other-agents) [NextGraphify with Claude Code](/integrations/claude-code) # Graphify MCP for Vercel Source: https://docs.graphify.com/integrations/vercel [Cloud] Connect Vercel projects to Graphify's hosted MCP server through the Marketplace integration or Vercel Connect. [Graphify for Vercel](https://vercel.com/marketplace/graphify) connects Vercel projects to Graphify's hosted MCP server. Your app or agent can query indexed repositories for definitions, callers, dependencies, change impact, and repository knowledge with source references. ## Choose a Vercel path Graphify supports two Vercel paths. They call the same hosted MCP server, but the token is issued differently. | Path | Use it when | What Vercel gives your app | | - | - | - | | [Marketplace integration](#marketplace-integration) | A workspace owner or admin wants selected Vercel projects to call Graphify as one Graphify workspace. | `GRAPHIFY_MCP_URL` and a sensitive `GRAPHIFY_MCP_TOKEN` on each selected project. | | [Vercel Connect connector](#vercel-connect-connector) | Each person using your app should authorize their own Graphify account. | A runtime token from `@vercel/connect` for that signed-in user. | Both paths call the same hosted server used by [Graphify MCP for VS Code](/integrations/vscode), [Graphify MCP for JetBrains](/integrations/jetbrains), [ChatGPT, Codex, and Dots](/integrations/chatgpt), and [Graphify MCP for OpenClaw](/integrations/openclaw). ## Marketplace integration Use the Marketplace integration when a Vercel project needs a project-scoped MCP token managed from Vercel. When you connect Graphify from the Vercel Marketplace: * You authorize an existing Graphify workspace. * You choose the Vercel projects and deployment environments that should receive Graphify MCP access. * Each selected project gets its own MCP token. * The integration adds `GRAPHIFY_MCP_URL` and a sensitive `GRAPHIFY_MCP_TOKEN` to each selected project. * Your Graphify plan, usage limits, and billing stay with Graphify. ### Before you start * You are a Graphify workspace owner or admin. * You have a repository indexed in Graphify, with agent access enabled. * You can select the Vercel projects and deployment environments that should receive Graphify MCP credentials. * You will keep the credentials in server-side code. Do not expose `GRAPHIFY_MCP_TOKEN` to browser code. See [pricing](https://graphify.com/pricing) for Graphify plans. ### 1. Install from Vercel Marketplace 1. Open [Graphify for Vercel](https://vercel.com/marketplace/graphify). 2. Select **Connect Account**. 3. Authorize the existing Graphify workspace. 4. Select the Vercel projects that should receive Graphify MCP access. 5. Choose deployment environments. Production is selected by default; preview access is optional. After install, redeploy the selected projects so the new variables are available at runtime. For local development, pull project environment variables with the Vercel workflow you already use. ### 2. Check the environment variables The integration adds two variables to each chosen project: | Variable | Purpose | | - | - | | `GRAPHIFY_MCP_URL` | The hosted Graphify MCP endpoint for the project. | | `GRAPHIFY_MCP_TOKEN` | A sensitive project token for that Vercel project. | Server-side code sends `GRAPHIFY_MCP_TOKEN` to the Graphify MCP server as a Bearer token. Use the `GRAPHIFY_MCP_URL` value from the project environment instead of hard-coding the endpoint. ### 3. Call Graphify from eve eve is Vercel's agent project. Put the connection in `agent/connections/graphify.ts`: ```typescript theme={null} import { defineMcpClientConnection } from 'eve/connections' const graphifyMcpUrl = process.env.GRAPHIFY_MCP_URL const graphifyMcpToken = process.env.GRAPHIFY_MCP_TOKEN if (!graphifyMcpUrl || !graphifyMcpToken) { throw new Error('Graphify MCP environment variables are missing') } export default defineMcpClientConnection({ url: graphifyMcpUrl, description: 'Graphify code graph: definitions, callers, dependencies, impact, and repository knowledge.', auth: { credentialOwner: 'app', getToken: async () => ({ token: graphifyMcpToken }), }, }) ``` eve keeps the credential out of the model. Its static-token auth sends the token as a Bearer token when it connects to the MCP server. ### 4. Call Graphify from the AI SDK The AI SDK can load tools from Graphify's MCP server and pass them to a model. This sample reads the Marketplace variables from server-side code: ```typescript theme={null} import { createMCPClient } from '@ai-sdk/mcp' import { generateText, isStepCount } from 'ai' const graphifyMcpUrl = process.env.GRAPHIFY_MCP_URL const graphifyMcpToken = process.env.GRAPHIFY_MCP_TOKEN if (!graphifyMcpUrl || !graphifyMcpToken) { throw new Error('Graphify MCP environment variables are missing') } const client = await createMCPClient({ transport: { type: 'http', url: graphifyMcpUrl, headers: { Authorization: `Bearer ${graphifyMcpToken}` }, }, }) try { const { text } = await generateText({ model: 'openai/gpt-5.4', tools: await client.tools(), stopWhen: isStepCount(10), prompt: 'Use Graphify to help with this request.', }) } finally { await client.close() } ``` The model id above is the Vercel listing's sample. Graphify does not choose the model for your app. ### 5. Manage or remove the integration Use **Configure** in Vercel to manage the Graphify connection. * Disconnecting a project revokes that project's token. * Removing the integration revokes every token from that installation. * Your Graphify account and subscription stay intact after removal. * Repository indexing and agent access are managed in Graphify. ## Vercel Connect connector Use Vercel Connect when each person using the app should authorize their own Graphify account. Connect gives your app a token for that person. The app sends that token to Graphify. `acme-graphify` below is the example name from the [Connect listing](https://vercel.com/connect/graphify). Pick your own. The token id is `graphify/` plus that name. When you create a Graphify connector: * Vercel records the connection under your linked project. * The person using your app completes Graphify authorization. * Your app calls `getToken` at runtime for the current subject. * Graphify receives a Bearer token for that person, not the Marketplace project token. ### Before you start * A Vercel account and the [Vercel CLI](https://vercel.com/docs/cli). Connect is available on all Vercel plans. See [Vercel Connect](https://vercel.com/docs/connect). * A Vercel project. `vercel link` attaches this directory to it. The project can be empty. It exists so Vercel can issue a token to your code. * A repository indexed in your Graphify workspace. Sign in at [app.graphify.com](https://app.graphify.com), connect a repository, and wait until its status is **Indexed**. See [Repositories and builds](/platform/repositories). If a coding agent is writing this Vercel app, the Connect listing's first command installs Vercel's Connect skill: ```bash theme={null} npx skills add vercel/vercel-plugin --skill vercel-connect ``` That skill is Vercel's. It is separate from `graphify install`. ### 1. Create the connector [Open Graphify on Vercel Connect](https://vercel.com/connect/graphify) and choose **Create Connector**, or run this from the project directory: ```bash theme={null} vercel link vercel connect create graphify --name acme-graphify vercel env pull ``` `vercel env pull` writes a local `VERCEL_OIDC_TOKEN` so `getToken` can run on your machine. On a Vercel deployment, Vercel supplies that token. If a later call cannot authenticate, run `vercel env pull` again. The local token is short-lived. Details are in the [Connect quickstart](https://vercel.com/docs/connect/quickstart). Complete the Graphify authorization Vercel shows. The listing requests access for the person using the app, under that person's Graphify permissions. ### 2. Ask Connect for a token `@vercel/connect` is the Connect SDK. Install it, then call `getToken` with the id of the person using your app. `user_123` below is a placeholder. ```bash theme={null} npm install @vercel/connect ``` ```typescript theme={null} import { getToken } from '@vercel/connect' const userId = 'user_123' const token = await getToken('graphify/acme-graphify', { subject: { type: 'user', id: userId }, }) ``` Send `token` to `https://api.graphify.com/mcp` as `Authorization: Bearer `. The eve and AI SDK sections below do that for you. ### 3. Call Graphify Use one of the two stacks from the listing, or send the Bearer token from your own route. #### eve eve is Vercel's agent project. You declare Graphify as a connection, and eve attaches the tools. ```bash theme={null} npx eve@latest init my-agent cd my-agent npm install @vercel/connect vercel link vercel connect create graphify --name acme-graphify vercel env pull ``` Add `agent/connections/graphify.ts`: ```typescript theme={null} import { defineMcpClientConnection } from 'eve/connections' import { connect } from '@vercel/connect/eve' export default defineMcpClientConnection({ url: 'https://api.graphify.com/mcp', description: 'Graphify tools and data', auth: connect('graphify/acme-graphify'), }) ``` ```bash theme={null} npm run dev ``` #### AI SDK The AI SDK is Vercel's library for calling a model from your code and handing it tools. This sample is the one on the listing, including the model id. ```bash theme={null} npm install ai @ai-sdk/mcp @vercel/connect vercel link vercel connect create graphify --name acme-graphify vercel env pull ``` ```typescript theme={null} import { getToken } from '@vercel/connect' import { createMCPClient } from '@ai-sdk/mcp' import { generateText, isStepCount } from 'ai' const userId = 'user_123' const token = await getToken('graphify/acme-graphify', { subject: { type: 'user', id: userId }, }) const client = await createMCPClient({ transport: { type: 'http', url: 'https://api.graphify.com/mcp', headers: { Authorization: `Bearer ${token}` }, }, }) try { const { text } = await generateText({ model: 'openai/gpt-5.4', tools: await client.tools(), stopWhen: isStepCount(10), prompt: 'Use Graphify to help with this request.', }) } finally { await client.close() } ``` ## If something fails | What you see | What to do | | - | - | | Marketplace variables are missing | In Vercel, confirm the project was selected during install, then redeploy the project. For local development, pull the project environment variables again. | | The Marketplace token is rejected | Check that the project is still connected in Vercel, the app was redeployed after install, and server-side code sends `GRAPHIFY_MCP_TOKEN` as `Authorization: Bearer `. | | `getToken` cannot authenticate | Run `vercel env pull` again from the linked project. The local OIDC token expires. A deployment on Vercel receives its own token. | | The Connect token id is rejected | The id is `graphify/` plus the `--name` you passed to `vercel connect create`. `graphify/acme-graphify` matches the example name only. | | No repositories, or empty answers | That repository is not indexed yet, or it is in a different workspace. Check its status in [Repositories and builds](/platform/repositories). | | The tools are the ten local ones | This page uses the hosted server. The ten-tool list in the [MCP tool reference](/reference/mcp-tools) is the graph on the machine. | ## Related > **[Graphify MCP for VS Code](/integrations/vscode)** > > Connect an editor to the same hosted server. > **[Vercel Connect](https://vercel.com/docs/connect)** > > How Connect issues a token and how a project is allowed to ask for one. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/integrations/vercel.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fintegrations%2Fvercel) [PreviousGraphify MCP for OpenClaw](/integrations/openclaw) [NextOther coding agents](/integrations/other-agents) # Graphify MCP for VS Code Source: https://docs.graphify.com/integrations/vscode [Cloud] Connect VS Code agents to your indexed repositories through Graphify's hosted MCP server. The **Graphify MCP** extension registers Graphify's hosted MCP server in VS Code. Your agent can then search the repositories you have indexed in [Graphify Cloud](https://app.graphify.com), follow callers and dependencies, and judge what a change reaches. VS Code handles the sign-in, the server trust prompt, and every tool approval. There is no API key to paste and no local process to run. ## Before you start * VS Code 1.102 or later. * An agent chat model available in VS Code. The extension does not include one. * A repository indexed in your Graphify workspace. Sign in at [app.graphify.com](https://app.graphify.com), connect a repository, and wait for its status to reach **Indexed**. See [Repositories and builds](/platform/repositories). ## 1. Add the MCP server **Install the extension** Install [Graphify MCP](https://marketplace.visualstudio.com/items?itemName=graphify-labs.graphify-mcp) from the Visual Studio Marketplace, or search for **Graphify MCP** by **Graphify Labs** in the Extensions view. The extension registers `https://api.graphify.com/mcp` over Streamable HTTP. It does not read or upload your local files, and it stores no credentials of its own. **Add the endpoint by hand** Open the Command Palette (`Ctrl + Shift + P`, or `Cmd + Shift + P` on macOS) and run **MCP: Open User Configuration**. Add the server to `mcp.json`: ```json theme={null} theme={null} { "servers": { "graphify": { "type": "http", "url": "https://api.graphify.com/mcp" } } } ``` Use one path or the other. If you keep this entry and also install the extension, the same tools appear twice. ## 2. Start the server and sign in ## 1. Start it Run **MCP: List Servers** from the Command Palette and select **Graphify**, then start the server. ## 2. Authorize Your browser opens so you can sign in to Graphify and grant access. Choose the workspace that holds the repository you want to query. ## 3. Confirm the tools loaded Return to **MCP: List Servers** and check that Graphify is running. Open an agent chat and enable Graphify's tools. ## 3. Ask a question Start by confirming what the connection can see: ```text theme={null} theme={null} List the repositories I can query with Graphify. ``` Then pick a repository from the answer and ask about its code: * `Who calls the function that validates a session token?` * `Show me how a request reaches the database in this repository.` * `What does this change affect?` * `Which tests cover the billing module?` * `Remember that the retry limit lives in the queue worker.` Answers are graph evidence from the files Graphify indexed, not a verified result. Open the source lines an answer cites before you rely on it. Some tools write workspace memory or switch the selected workspace. Read each tool request and approve it only when that is what you meant. ## Commands | Command | What it does | | - | - | | **Graphify: Open Dashboard** | Opens your workspace in the browser. | | **Graphify: Open MCP Documentation** | Opens the setup instructions and tool reference. | ## If something fails | What you see | What to do | | - | - | | Graphify is not in **MCP: List Servers** | Check that VS Code is 1.102 or later, then reload the window. | | The tools return nothing for a repository | That repository is not indexed yet, or it is in a different workspace. Check its status in [Repositories and builds](/platform/repositories). | | The agent reports an authorization problem | Stop the server in **MCP: List Servers**, start it again, and complete the browser sign-in. | | Every Graphify tool appears twice | You have both the extension and a manual `mcp.json` entry. Remove one. | | No tools appear in chat | No agent model is available, or Graphify's tools are switched off for that chat. | ## Related > **[Agents and integrations](/platform/connections)** > > Connect other clients from the Cloud workspace and manage its integrations. > **[Graphify MCP for JetBrains](/integrations/jetbrains)** > > Connect JetBrains AI Assistant to the same hosted server. > **[Connect the graph MCP server](/mcp/overview)** > > Run a local MCP server against a graph on your own machine instead. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/integrations/vscode.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fintegrations%2Fvscode) [PreviousGraphify Cloud](/integrations/cloud) [NextGraphify MCP for JetBrains](/integrations/jetbrains) # Search the docs from your agent Source: https://docs.graphify.com/mcp/docs-search [Both] Connect to the documentation MCP, separately from your repository graph. The documentation MCP answers questions about **using Graphify**. The [graph MCP server](/mcp/overview) answers questions about **your repository**. ## Website documentation endpoint The existing Graphify website exposes a public, Streamable HTTP MCP endpoint: ```text theme={null} https://graphify.com/api/mcp ``` It provides `search_graphify_docs`, a search tool over the website’s documentation, concepts, integrations, and related content. It does not read your local repository. ```bash theme={null} claude mcp add --transport http graphify-docs https://graphify.com/api/mcp ``` For a JSON-based client: ```json theme={null} { "mcpServers": { "graphify-docs": { "url": "https://graphify.com/api/mcp" } } } ``` ## Mintlify documentation This site also provides Mintlify’s documentation features, including Markdown exports and an LLM index at `/llms.txt`. Use the page’s contextual menu to copy a page or connect a supported client. The existing website endpoint and this Mintlify site have separate content indexes. ## Example questions * How do I install the Graphify skill in Cursor? * How do I run a code-only extraction? * What is the difference between query, path, and explain? [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/mcp/docs-search.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fmcp%2Fdocs-search) [PreviousServe a graph over HTTP](/mcp/shared-http) # Connect the graph MCP server Source: https://docs.graphify.com/mcp/overview [Local] Let your assistant query your repository through ten structured graph tools. The graph MCP server reads a Graphify graph and exposes exploration tools to compatible clients. Start by building `graphify-out/graph.json` using the [quickstart](/quickstart). ## Install the MCP extra ```bash theme={null} uv tool install "graphifyy[mcp]" ``` This installs the `graphify-mcp` executable into the same tool environment as Graphify. If uv reports an existing installation without the extra, reinstall with `uv tool install --reinstall "graphifyy[mcp]"`. ## Configure a local client Use an **absolute path** to the graph. GUI apps often start with a different working directory from your terminal. **Claude Code** ```bash theme={null} claude mcp add --transport stdio graphify -- graphify-mcp /absolute/path/to/repo/graphify-out/graph.json ``` **Cursor** Add a server entry to your user or project MCP configuration: ```json theme={null} { "mcpServers": { "graphify": { "command": "graphify-mcp", "args": ["/absolute/path/to/repo/graphify-out/graph.json"] } } } ``` **Codex** ```bash theme={null} codex mcp add graphify -- graphify-mcp /absolute/path/to/repo/graphify-out/graph.json ``` Or configure the equivalent server in Codex’s MCP settings. **Other clients** Choose the stdio transport, set the command to `graphify-mcp`, and pass the absolute graph path as the first argument. If the client cannot find the executable, replace it with the absolute path to `graphify-mcp` in your installed tool environment. For client-specific setup, visit the [Graphify MCP connection guide](https://graphify.com/mcp). Choose your client there for its configuration instructions. That page also covers the hosted Graphify Cloud endpoint; the stdio setup above connects to a graph on your own machine. ## Check the connection Refresh your client’s MCP connections. Ask it to call `graph_stats` first, then `query_graph` with a question about the repository. The [tool reference](/reference/mcp-tools) lists the current schemas. ```json theme={null} {"question": "authentication flow", "token_budget": 1500} ``` ## Python environment alternative If you installed Graphify into a virtual environment, activate that environment first, then run: ```bash theme={null} python -m graphify.serve /absolute/path/to/repo/graphify-out/graph.json ``` Use the interpreter where the MCP extra is installed. In a GUI client, set the command to that interpreter’s absolute path. Your shell’s Python can differ from uv’s tool environment. ## Scope of the tools Graph exploration tools retrieve the saved graph. The PR tools additionally read GitHub context through `gh`; they are not an entirely offline workflow. MCP `triage_prs` returns data for the calling assistant to reason over. To share a graph through a URL, use the [HTTP server guide](/mcp/shared-http). To search Graphify’s documentation instead of your code graph, use the [docs search MCP](/mcp/docs-search). [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/mcp/overview.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fmcp%2Foverview) [PreviousBuildkite (Test Impact)](/integrations/buildkite) [NextServe a graph over HTTP](/mcp/shared-http) # Serve a graph over HTTP Source: https://docs.graphify.com/mcp/shared-http [Local] Run a shared MCP endpoint with explicit network and authentication settings. The same ten tools can run over MCP Streamable HTTP. A local HTTP server is useful when a client connects by URL instead of launching a stdio process. ## Start on localhost ```bash theme={null} graphify-mcp /absolute/path/to/graphify-out/graph.json --transport http --port 8080 ``` The endpoint is `http://127.0.0.1:8080/mcp`. The default host is loopback-only. ## Share within your environment Set `GRAPHIFY_API_KEY` in the server environment using your secret manager. Then start with the intended bind address: ```bash theme={null} graphify-mcp /data/graph.json --transport http --host 0.0.0.0 --port 8080 ``` Clients authenticate with `Authorization: Bearer ` or `X-API-Key`. Use a private network or an authenticated TLS proxy for traffic beyond the local machine. A graph can contain proprietary source context. ## Server options | Option | Default | Purpose | | - | - | - | | `--transport` | `stdio` | Select `stdio` or `http`. | | `--host` | `127.0.0.1` | HTTP bind address. | | `--port` | `8080` | HTTP port. | | `--path` | `/mcp` | HTTP endpoint path. | | `--api-key` | `GRAPHIFY_API_KEY` | Require a client key; prefer the environment variable to placing a secret in shell history. | | `--json-response` | Off | Use JSON responses rather than SSE streams. | | `--stateless` | Off | Disable per-session state. | | `--session-timeout` | `3600` | Idle session timeout in seconds; `0` disables reaping. | ## Docker The source repository includes a Dockerfile. Build it from that checkout: ```bash theme={null} docker build -t graphify . docker run --rm -p 127.0.0.1:8080:8080 \ -v "$PWD/graphify-out:/data:ro" \ -e GRAPHIFY_API_KEY \ graphify /data/graph.json --transport http --host 0.0.0.0 ``` This example publishes to localhost and mounts the graph read-only. Set `GRAPHIFY_API_KEY` before running it. Make deliberate network and authentication choices before exposing the endpoint to other hosts. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/mcp/shared-http.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fmcp%2Fshared-http) [PreviousConnect the graph MCP server](/mcp/overview) [NextSearch the docs from your agent](/mcp/docs-search) # Agents and integrations Source: https://docs.graphify.com/platform/connections [Cloud] Connect coding agents to your Cloud workspace and manage its integrations. Connect your coding assistant to the hosted workspace from **MCP** in [Graphify Cloud](https://app.graphify.com). This lets the assistant use your Cloud context while you work in its editor or terminal. ## Connect a coding assistant 1. Open the workspace's **MCP** page or choose **Connect agent** from Overview. 2. Choose your client and follow its setup instructions. 3. Complete the Graphify sign-in and select the intended workspace when prompted. 4. Return to the assistant and confirm that its Graphify connection is available. The website's [MCP client guide](https://graphify.com/mcp) includes instructions for Claude Code, Codex, Cursor, GitHub Copilot, and other clients. ## Shared knowledge alongside your own memory Your agent can keep its own preferences and session memory. Graphify adds shared knowledge connected to your repositories, with sources and history that authorized agents and teammates can inspect. It does not automatically synchronize with another memory store. After connecting, try one source-linked question about a repository you work on. For implementation tasks, include the files you are changing so supported contextual guidance can point to relevant reusable code. When available, `graphify_patterns` lets you inspect examples explicitly. Follow the tools and readiness returned by your authenticated connection. Personal suggestion settings apply only when Graphify can identify the current human member reliably. Service and shared credentials use workspace controls and neutral personalization. ## Hosted and local MCP The hosted connection uses your Cloud identity and workspace access. A local `graphify-mcp` process reads a graph on your machine. Follow [Connect the graph MCP server](/mcp/overview) when you want that local workflow. To search this documentation from an assistant, use the separate [docs search MCP](/mcp/docs-search). ## Other workspace integrations **Integrations** lists the connections available to the workspace. The console currently labels that area **Early access**; follow the status and setup flow displayed for each provider. Repository-provider connections begin in [Repositories](/platform/repositories). Google Drive is connected from **Connectors**. Follow [Connect Google Drive](/platform/google-drive). Account and organization controls live in the user menu, including **Settings**, **Billing**, and **Members** where available. ## Buildkite test selection Connect **BuildKite (Test Impact)** from Integrations to run tests affected by a pull request. A workspace owner or admin creates a CI token; your Buildkite pipeline sends the commit range and uploads the returned test steps. Follow the [Buildkite integration guide](/integrations/buildkite) for token setup, a working pipeline example, full-suite fallback, and troubleshooting. The optional **Show test selection on pull requests** switch adds advisory review context; it does not run or gate tests. ## Connection troubleshooting Check that you signed in to the intended workspace and that the repository has finished indexing. If the assistant reports an authorization problem, refresh its Graphify sign-in. For client-specific configuration, return to the [MCP guide](https://graphify.com/mcp). [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/connections.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Fconnections) [PreviousConnect Google Drive](/platform/google-drive) # Console tour Source: https://docs.graphify.com/platform/console [Cloud] Tour the Cloud workspace, from repository graphs and Wiki to reviews, verification, Learning, and memory. Open [Graphify Cloud](https://app.graphify.com) to explore your workspace. This tour shows the product screens and the context available in each view. ## Overview **Overview** brings your repository graphs and workspace activity together. The graph cards show indexing status and repository context; workspace statistics and recent builds help you see what has been processed. **Connect agent** opens the path to using that context from your coding assistant. ![Graphify Cloud Overview with repository graph cards, workspace statistics, and recent builds](https://graphify.com/assets/shots/overview.webp) ## Cross-repository graph Use **Graphs → Cross-Repository** to explore relationships spanning multiple repositories. The view combines the graph canvas with node and edge counts, provenance categories, community filters, and node search. This helps you follow connections that cross a service or repository boundary. ![Graphify cross-repository graph with community filters, node search, and provenance counts](https://graphify.com/assets/shots/graph.webp) See [how Graphify works](/concepts/architecture) for graph structure and [edges and provenance](/concepts/provenance) for the meaning of the evidence labels. ## Pull request reviews **Reviews** lists review runs for a selected repository. Each entry connects a pull request to its review status, findings, and affected code. Use that context to understand the reach of a change before investigating individual findings. ![Graphify Reviews showing pull requests, review status, findings, and blast-radius information](https://graphify.com/assets/shots/reviews.webp) For the meaning and limits of verification verdicts, see [formal verification](/platform/verification). To investigate pull requests using the local CLI, see the [pull request guide](/guides/pull-requests). ## Agent memory **Memory** organizes remembered facts around the entities they describe. Select a repository, search for a fact or entity, and inspect the stored context alongside its provenance. The view also shows memory coverage and grounding information, helping you distinguish recorded facts from facts anchored to a graph node. ![Graphify Memory showing remembered facts, entities, grounding metrics, and source context](https://graphify.com/assets/shots/memory.webp) Use **Connect an agent** to bring your coding assistant into the workspace, or follow the [MCP client setup guide](https://graphify.com/mcp). ## Formal verification **Formal Verification** lists runs for your repositories and pull requests. Expand a run to inspect changed functions, verdicts, and available inputs or outputs that explain a behavioral difference. The run status tells you whether processing finished; the per-function verdict tells you what was established. Read the [formal verification guide](/platform/verification) before interpreting a result. ## Wiki **Wiki** turns an indexed repository graph into navigable documentation. Choose a repository, browse its articles and table of contents, search the article text, or ask a question grounded in the wiki. See [Wiki](/platform/wiki) for indexing requirements and empty states. ## Learning Open **Learn** to see how trusted review feedback shapes advisory findings. The **Learning** view shows learned dismissals, suppressions, and recent feedback. It is a read-only view of that history; feedback is submitted on pull requests. Learning does not alter formal verification verdicts. See [Learning](/platform/learning) for the feedback commands and their scope. ## Workspace operations * [Profile](/platform/profile): achievements, the last 7 days of Performance, and Power Ranking. * [Repositories and builds](/platform/repositories): connect GitHub or GitLab repositories, configure analysis, and inspect indexing runs. * [Contributors](/platform/contributors): explore authorship and graph reach where the contributor overlay is available. * [Agents and integrations](/platform/connections): connect your coding assistant through MCP and find workspace connection controls. Some views depend on workspace access or a completed repository index. Their guides explain what to check when a view is unavailable or empty. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/console.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Fconsole) [PreviousGraphify Cloud](/platform/overview) [NextTrace who calls this](/platform/trace) # Contributors Source: https://docs.graphify.com/platform/contributors [Cloud] Explore authorship, graph reach, and available signing evidence across a repository. **Contributors** connects repository authorship with graph reach and commit-signing evidence. Use it to understand who has worked on heavily depended-on code and where to investigate an ownership or signing question. Open **Contributors** in [Graphify Cloud](https://app.graphify.com) when it is enabled for your workspace, then choose an indexed repository. ## Inspect ownership and reach Select a contributor to inspect available authored-node counts, affected graph context, and the most widely depended-on code associated with that identity. Follow source links to investigate the actual change or repository history. The view can include signing coverage, AI-assist indicators, and advisory risk signals when the repository's contributor overlay contains that information. A metric that was not measured should remain unmeasured rather than being read as zero. ## Interpret the evidence Git author strings do not by themselves verify a person's identity. Distinguish a resolved account and signed-commit evidence from an unverified name or address. This is an advisory investigation surface, not an accusation or a measure of developer performance. Read each signal's supporting evidence and follow the relevant commits before drawing conclusions. ## Missing contributor data The contributor overlay is produced at index time when enabled for the workspace. If the view says there is no overlay yet, check [Repositories and builds](/platform/repositories) and the feature's workspace availability. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/contributors.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Fcontributors) [PreviousLearning](/platform/learning) [NextProfile](/platform/profile) # Connect Google Drive Source: https://docs.graphify.com/platform/google-drive [Cloud] Add a Google Drive folder so the workspace can search its documents. The **Google Workspace** tile on **Connectors** connects Google Drive. A folder you add becomes a repository the workspace can search. Read-only access. Graphify never edits your files. ## Before you start * The workspace is on a paid plan. On the Free plan, **Google Workspace** offers **View plans**. * You are a workspace owner or admin. Anyone else sees **Ask a workspace owner or admin to connect Google Drive.** * The Google account can open the folder, including a folder on a shared drive. ## Connect the account 1. Open **Connectors** in [Graphify Cloud](https://app.graphify.com). 2. Under **Knowledge**, choose **Google Workspace**. 3. Choose **Connect Google Drive** and finish the Google sign-in. The dialog then shows the connected account and **Connected · Syncs automatically**. One Google account serves the workspace. The person who signed in is the person who can add folders. ## Add a folder 1. Choose **Google Workspace**, then **Choose folder**. If the Google window does not open, allow pop-ups for Graphify and try again. 2. Pick a folder. The picker is titled **Choose a folder to index**, and it includes shared drives. 3. Confirm that everyone in the workspace can search this folder and read answers from it, including people without access to the files in Google Drive. 4. Select **I understand everyone in this workspace can read this folder's contents.** 5. Choose **Add folder**. The confirmation says the folder was added and is **Waiting to sync**. Open **Repositories** and choose **Drive** to see it. A folder with no readable files is refused. Choose another folder. ## Read the folder The row shows how many files Graphify could read, and **Checked** with the time of the last listing. Expand the row for **Last synced**, **Graph nodes**, and **Updates**. **Checked** is the last time Graphify listed the folder. **Last synced** is the last finished graph build. The row can say **Up to date** while **Last synced** is older, when the latest listing matches the graph already being served. | Status | Meaning | | - | - | | **Waiting to sync** | A build is queued. | | **Reading** | Graphify is building the graph. | | **Up to date** | The latest listing matches the graph being served. | | **Changes found** | The listing has changed, and the served graph is behind it. | | **Sync failed** | The latest build did not finish. | | **Not syncing** | Syncing was stopped, the folder is paused, or Google needs a reconnect. | | **Checking status** | Graphify does not have a status for this folder yet. | **Updates** says **Syncs automatically** while the folder is enabled. Graphify lists an enabled folder every 15 minutes and builds a new graph when that list has changed. If a check fails, Graphify retries on its own. The wait grows after each failure, up to 6 hours. After the first successful sync, the expanded row offers **Open graph**, **Wiki**, **Ask**, and **Open in Drive**. Pull request reviews apply to GitHub and GitLab repositories. Search a Drive folder from **Open graph**, **Wiki**, or **Ask**. ## Files Graphify reads Google Docs, Sheets, and Slides, plus PDF, Word, Excel, PowerPoint, CSV, Markdown, text, and image files. Expand a folder to see files that could not be read. The reason sits next to the file name. The other files in that folder stay searchable. A file is skipped when Graphify cannot read the type, the connected account cannot download it, Google could not export it, or the file is too large. ## Stop a folder A workspace owner or admin opens the folder's options and chooses **Stop syncing**. Graphify stops reading that folder. The existing graph stays searchable, and the row says **Not syncing**. ## Change the account **Connection settings** opens from the **Google Workspace** tile. A workspace owner or admin can use it. Anyone else sees **Done**. * Choose **Change account**, or **Reconnect with my account**, to sign in with a different Google account. Syncing stops for the existing folders. Add those folders again from the new account. * Choose **Disconnect** to stop every folder. Existing graphs remain searchable. * Choose **Reconnect Google Drive** when the dialog says Google access expired. Existing graphs stay available while you reconnect. ## Fix a connection problem * The tile says **Reconnect needed**, or the dialog says Google access expired. Choose **Reconnect Google Drive**. * The folder is not in the picker, or adding it says the folder is unavailable. Use a Google account that can open that folder. * Adding a folder says only the person who connected the account can add folders. That person adds it, or an owner or admin chooses **Change account**. * The folder says **Syncing is paused. Google Drive requires a paid plan.** Open **Billing** and move the workspace to a paid plan. * A check says Google Drive did not respond, or the folder took too long. Leave the folder enabled. Graphify retries on its own. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/google-drive.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Fgoogle-drive) [PreviousRepositories and builds](/platform/repositories) [NextAgents and integrations](/platform/connections) # Repository graphs Source: https://docs.graphify.com/platform/graphs [Cloud] Explore code relationships within a repository and across your connected workspace. Use **Graphs** in [Graphify Cloud](https://app.graphify.com) to explore code relationships within a repository or across your workspace. ## Choose your scope Expand **Graphs** in the sidebar: * **Single Repository** focuses on one indexed codebase. * **Cross-Repository** follows relationships that cross repository or service boundaries. Choose the repository context you need before interpreting a node or connection. A missing connection can reflect the selected scope or the indexed source rather than the absence of a runtime dependency. ## Structure and reusable patterns Where enabled in Cloud, the existing Graphs page offers **Structure**, **Graph**, and **Patterns**. Existing graph links continue to open the detailed explorer. * **Structure** shows declared package boundaries, directory groupings, repository dependencies, consumers, and declared external libraries. A directory grouping is not a declared architectural boundary. * **Graph** keeps the detailed node and relationship explorer. * **Patterns** shows resolved implementations and source-derived conventions from the indexed revision. Search for a component, utility, or static style token, then select **View examples**. An **Inferred convention** needs at least three distinct production consumer files in a coherent scope. Tests, stories, generated code, and vendored dependencies do not count. Dynamic or unresolved evidence is omitted. Repetition is evidence of usage, not correctness or a universal preference. The evidence drawer shows sources, scope, indexed revision, coverage, and available snapshot/control history. **Correct** saves an attributed decision through Memory and ignores the inferred convention. **Ignore this convention** persists across reindexing; enable **Include ignored conventions** to restore it. These controls apply to repository guidance and require write access. Catalogs are optional. Older indexes and unsupported coverage remain usable in the Graph view. Opening this page does not trigger reindexing. Snapshot history starts with available catalogs; Graphify does not reconstruct earlier personal design choices. ## Explore the map Search for a node, inspect its neighbors, and use community filters to narrow the canvas. Node and edge totals help describe the current graph; provenance categories explain how its connections were obtained. ![Graphify Cloud cross-repository graph with community filters, node search, and provenance counts](https://graphify.com/assets/shots/graph.webp) The graph is useful for tracing a call path, finding dependent code, and identifying boundaries between services. Follow source references when you need to inspect the implementation behind a relationship. ## Read provenance Graphify distinguishes extracted relationships from inferred or ambiguous ones. Keep those labels visible when using graph context to assess a change. A traversable connection provides evidence to investigate; it is not a formal proof of application behavior. See [Edges and provenance](/concepts/provenance) for the evidence labels and [Formal verification](/platform/verification) for behavior comparisons. ## Keep the graph current The canvas reflects an indexed build. Check **Repositories** and **Builds** when recent code is missing. [Wiki](/platform/wiki) provides a written view of the same indexed repository, while [MCP](/platform/connections) makes workspace context available to your coding assistant. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/graphs.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Fgraphs) [PreviousWhen something fails](/platform/when-stuck) [NextWiki](/platform/wiki) # Learning Source: https://docs.graphify.com/platform/learning [Cloud] Use review feedback to reduce noise while keeping formal verification independent. Open **Learn** in [Graphify Cloud](https://app.graphify.com) to see how your team's pull request feedback shapes advisory reviews. Learning records dismissed findings, suppressed patterns, and the feedback behind them. ## Teach Graphify on a pull request Give feedback in the pull request conversation using the exact finding name from the Graphify review: ```text theme={null} @graphify wrong @graphify good @graphify suppress ``` | Command | Effect | | - | - | | `wrong` | Dismiss a specific finding. Trusted dismissals contribute to learned muting. | | `good` | Confirm a finding. This can contest an existing mute. | | `suppress` | Mute a rule or category, optionally scoped to a path. | Feedback comes from trusted members. Fork activity is excluded. Graphify can also use a flagged line being changed before merge as a weaker, passive signal. ## Read the Learning dashboard **Muted findings**, **Muted patterns**, and **Feedback last 30d** summarize the workspace. The detail panels explain those totals: * **Learned dismissals** identify individual findings. Inspect the repository, dismissal history, and any conflicting confirmation. Dismissals are weighted and decay over time. * **Suppressions** show muted rules and their path scope, with the actor and pull request that introduced them. * **Feedback activity** shows recent commands and the findings or categories they refer to. These panels are read-only. Give feedback on the pull request rather than looking for a dashboard switch to restore or edit a suppression. ## What learning changes Learning adjusts what advisory review surfaces and what stays quiet. It does **not** change the formal verifier, proof verdicts, counterexamples, or witnesses. The **Verifier adjustments** counter remains zero by design. See [formal verification](/platform/verification) to interpret proof and behavior-change results. ## Missing feedback If **Action needed** reports a pending GitHub Issues permission, an installation administrator must approve the requested permission before PR-conversation feedback can be processed. Learning data also depends on the feature being enabled for your workspace. An empty panel can simply mean no eligible feedback has been recorded yet. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/learning.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Flearning) [PreviousFormal verification](/platform/verification) [NextContributors](/platform/contributors) # Agent memory Source: https://docs.graphify.com/platform/memory [Cloud] Explore remembered facts, their entities, and the source evidence behind them. **Memory** makes recorded agent context inspectable in [Graphify Cloud](https://app.graphify.com). Facts are organized around the entities they describe, with source and grounding information alongside them. ## How Memory complements your agent Your agent can keep its own preferences and session memory. Graphify adds shared knowledge connected to your repositories, with sources and history that authorized agents and teammates can inspect. Some knowledge can overlap. Graphify does not automatically synchronize with or replace another memory store. Existing visibility and access controls still apply. Explicit instructions and human decisions take precedence over inferred conventions. Use the record's source and history views to distinguish what code shows, what was delivered to an agent, and what a person explicitly confirmed. Delivery is not proof that an agent followed the guidance. Attribute a design choice to someone only when a recorded decision supports it. ## Explore remembered context 1. Open **Memory** and select a repository. 2. Search for a fact or entity, or choose an entity from the list. 3. Read its remembered facts and inspect the available source references, provenance, and graph anchors. ![Graphify Cloud Memory showing remembered facts, entities, and source grounding](https://graphify.com/assets/shots/memory.webp) Use memory to recover context from earlier agent work, investigate why a fact was recorded, and connect it to the current code graph. Coverage and grounding metrics help explain how much recorded context has a corresponding graph anchor. ## Grounding and provenance A remembered statement and an extracted code relationship are different kinds of evidence. Check where a fact came from and whether it is linked to a graph node. Source references and provenance are more useful than treating every stored fact as equally authoritative. For current implementation details, follow the graph anchor or open [Graphs](/platform/graphs). Read [provenance labels](/concepts/provenance) when evaluating an inferred connection. ## Connect an agent Use **Connect an agent**, or open the workspace's **MCP** page, to connect your coding assistant. See [Connect agents and integrations](/platform/connections). An empty repository has no recorded memories yet. Connect an agent and use the workspace's memory capabilities before expecting facts to appear. ## Memory and learning Memory stores contextual facts around entities. [Learning](/platform/learning) uses pull request feedback to adjust advisory reviews. Both are Cloud features, with separate purposes and controls. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/memory.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Fmemory) [PreviousWiki](/platform/wiki) [NextPull request reviews](/platform/reviews) # Graphify Cloud Source: https://docs.graphify.com/platform/overview [Cloud] Explore graphs, Wiki, reviews, formal verification, Learning, and shared agent memory in your hosted workspace. Graphify Cloud is the hosted Graphify workspace at [app.graphify.com](https://app.graphify.com). Its core features bring repository graphs, wiki, pull request reviews, formal verification, Learning, and agent memory into one connected workspace for your team and coding assistants. ## Start with your goal For workspaces in the personalized-discovery rollout, workspace creation includes one optional question: **What would you like to do first?** You can choose agent-assisted development, understanding code, reviewing changes, sharing knowledge, product integration, or exploring Graphify. Leaving it blank keeps a balanced introduction. **Overview → Explore Graphify** explains available capabilities and opens their destinations. Your goal changes recommendation emphasis; it keeps the sidebar and feature access stable. **Settings → Your experience** lets you change your goal, optionally add a work role, or choose **Only when I ask** to suppress unsolicited suggestions and automatic tours. Preferences are personal to you in each workspace. Structure and pattern discovery are rolling out separately and require a compatible index. Missing coverage is shown explicitly. Cloud, the local open-source package, and self-hosted installations can expose different capabilities; follow the availability shown by the installation you are using. ## Get started ## 1. Open your workspace Go to [app.graphify.com](https://app.graphify.com). Sign in with Google, GitHub, GitLab, or email. If you are new to Graphify, select **Create an account** from the login page. On the login page, **Forgot your password?** starts a reset. That link is on login, not on signup. ## 2. Connect a repository Follow the repository setup in your workspace. Graphify builds a graph of the repositories you connect. Use **Overview** to see your graphs, indexing status, and recent builds. ## 3. Explore the relationships Open a graph to inspect its nodes and connections. Use the cross-repository view when you need context across services and shared code. The [console tour](/platform/console) walks through the product screens. ## 4. Connect your coding agent Use **Connect agent** in the console, or follow the [client-specific MCP instructions](https://graphify.com/mcp). The hosted connection uses an OAuth sign-in so your assistant can access your Graphify workspace. ## Your workspace | Area | What you can explore | | - | - | | [Overview](/platform/console#overview) | Repository graphs, workspace activity, and recent builds. | | [Repository graphs](/platform/graphs) | Code relationships within a repository and across repositories. | | [Wiki](/platform/wiki) | Generated repository documentation with full-text search and grounded questions. | | [Pull request reviews](/platform/reviews) | Review runs, findings, and the code affected by a change. | | [Formal verification](/platform/verification) | Function-level comparisons, verdicts, and evidence of behavioral changes. | | [Learning](/platform/learning) | Review feedback, learned dismissals, and rule suppressions. | | [Agent memory](/platform/memory) | Remembered facts, entities, grounding, and provenance. | | [Contributors](/platform/contributors) | Authorship and graph reach with available signing evidence. | | [Repositories and builds](/platform/repositories) | Connections, analysis settings, indexing progress, and retries. | | [Agents and integrations](/platform/connections) | MCP access for coding assistants and workspace connections. | | [Profile](/platform/profile) | Your achievements, the last 7 days of Performance, and Power Ranking. | | [Buildkite test selection](/integrations/buildkite) | Select affected tests for CI and fall back to the full suite when needed. | > **[Tour the console](/platform/console)** > > Explore the Graphify Cloud screens and learn what each view is for. ## Common tasks * [Trace who calls this](/platform/trace): find the callers of a symbol and what a change can reach. * [Read a review and a verdict](/platform/read-a-result): what a finding and a verification result each mean. * [When something fails](/platform/when-stuck): an empty graph, a failed build, or a plan limit. ## Cloud and the open-source engine Graphify Cloud manages the hosted workspace for your connected repositories. The [open-source quickstart](/quickstart) runs the graph engine on your machine and writes the output into your project. Its CLI commands and local MCP setup are documented separately in these docs. Formal verification is part of Graphify Cloud. Available features, permissions, and usage limits depend on your workspace and plan; see [plans and pricing](/pricing/overview) for hosted allowances. For self-hosting, SSO/SAML, GitHub Enterprise, and procurement requirements, read the [Graphify Enterprise guide](/pricing/enterprise). [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/overview.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Foverview) [NextConsole tour](/platform/console) # Profile Source: https://docs.graphify.com/platform/profile [Cloud] Achievements, the last seven days of Performance, and how Power Ranking is scored. **Profile** is your personal page in [Graphify Cloud](https://app.graphify.com). Open it from the account menu. The older Activity address redirects here. Your personal stats come first. Workspace coverage and run history for the whole workspace follow below them. ## Achievements Achievements are lifetime. They do not reset each week. A badge you have not earned stays hidden. | Badge | What earns it | Tiers | | - | - | - | | First Graph | You built a Cloud graph from a connected repository | 1 | | Review Complete | Graphify reviewed pull requests you authored | 1, 50, 100 | | Pair Extraordinaire | Graphify reviewed pull requests that you then merged | 1, 50, 100 | | Merge Ready | You merged reviewed pull requests that had no unresolved high-risk findings | 1, 50, 100 | | Proof Companion | You completed formal verification on your pull requests. Every completed verdict counts | 1, 25, 50 | | Assistant Linked | Your assistant successfully queried your Cloud graph over MCP | 1, 100, 500 | Open a badge, choose **Share this milestone**, then **Download image**. The card includes your name, profile picture, badge, and tier. It does not include your email, workspace, or repository names. Profile also holds a display name, a bio of up to 50 characters, links for GitHub, LinkedIn, X, and a website, and an avatar you choose or upload. ## Performance Performance is your own counts for the **last 7 UTC days**: today, plus the six dates before it. It is not a Monday reset, and it is not a rolling 168 hours. | Count | What it includes | | - | - | | Graphs indexed | Successful Cloud graph builds counted for you | | PR reviews | Completed Graphify reviews of pull requests you authored | | MCP calls | Successful hosted queries of your Cloud graph over MCP | | Verifications | Completed verification verdicts counted for you | **Unavailable** means that count is not known yet. **0** means it was measured and is zero. A **Top N%** label on Performance appears only beside **Graphs indexed**. On Power Ranking, the same kind of label is your place among active Cloud users. A value of 92 means Top 8%. ## Power Ranking Power Ranking turns the same seven days into a score from 0 to 10, shown to one decimal place. | Signal | Weight | Most it can add | | - | - | - | | Completed PR reviews | 30% | 3 points | | Successful hosted MCP calls | 30% | 3 points | | Days active | 20% | 2 points | | Successful Cloud graph builds | 20% | 2 points | Reviews, MCP calls, and builds are compared with active Cloud users over the same seven days, you included. A very large MCP count still adds at most 3 points. An active day is a UTC day with at least one completed PR review, successful graph build, or successful hosted MCP call. Each active day adds one seventh of those 2 points. A verification by itself does not make a day active, and verifications do not change the score. The ranking updates hourly. It stays **Unavailable** when you had no qualifying activity in the window, when fewer than two people are in the comparison, when your account is not eligible for it, or when a ranking snapshot is not ready. > **[Read a review and a verdict](/platform/read-a-result)** > > How a review finding differs from a verification verdict. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/profile.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Fprofile) [PreviousContributors](/platform/contributors) [NextRepositories and builds](/platform/repositories) # Read a review and a verdict Source: https://docs.graphify.com/platform/read-a-result [Cloud] Tell a review finding from a verification verdict, and what each one is allowed to mean. A review and a verification answer different questions. Read both before you treat a pull request as safe. ## What a review is telling you Open **Reviews**, choose the repository, and select the run. Check the commit. The findings on that run describe that revision. A finding is advisory. It is a concern to investigate, with the code the change can affect. It is not proof that every changed function still behaves the same way. When the repository settings are on, the run can also include **Risky patterns (advisory)** and **Docs that may be stale (advisory)**. ## What a verdict is telling you Open **Formal Verification** and expand the run. The run status tells you whether processing finished. The per-function result tells you what was established: | Result | What it means | | - | - | | Proved equivalent (bounded) | The proof method established equivalence within its supported bounds. | | Behavior change | An input distinguishes the old and new implementations. Check whether that witness was reproduced or remains unconfirmed. | | No divergence sampled (not proven) | The inputs that ran showed no difference. This is empirical evidence, not a proof. | | Abstained | The method could not analyze the function within its supported domain or budget. | | Errored | Verification failed to produce a valid result for the function. | **Completed** describes the run's lifecycle. It does not mean every function was proved equivalent. A finished run can contain a mixture of these results. Use the [formal verification guide](/platform/verification) before you act on a verdict. > **[Review settings](/platform/reviews)** > > Turn risky patterns and stale docs on or off for a repository. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/read-a-result.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Fread-a-result) [PreviousTrace who calls this](/platform/trace) [NextWhen something fails](/platform/when-stuck) # Repositories and builds Source: https://docs.graphify.com/platform/repositories [Cloud] Connect repositories, configure analysis, and track or retry indexing builds. **Repositories** controls which codebases Graphify indexes. **Builds** shows the indexing runs that produce their graphs and wiki content. ## Connect a repository Open **Repositories** in [Graphify Cloud](https://app.graphify.com). Use **Connect GitHub** or **Connect GitLab**, then complete the provider's repository-access flow. Google Drive folders are added from **Connectors**. Follow [Connect Google Drive](/platform/google-drive). Return to the repository list to check indexing status. Provider and status filters help narrow a large workspace. | Status | Meaning | | - | - | | **Indexed** | A graph has been built and is available. | | **Building** | Indexing is running. | | **Queued** | The repository is waiting to build. | | **Failed** | The latest attempt did not finish successfully. | | **Paused** | Indexing is disabled for the repository. | ## Repository controls Open a repository's options to inspect available controls for **PR reviews**, **Fix suggestions**, **Formal verification**, and **Indexing**. Available actions depend on the workspace's configuration and access. The Indexing control pauses or enables indexing. Review and verification controls are separate; do not use an indexing toggle as a substitute for review configuration. ## When a repository is indexed A push to the repository's default branch starts an index of that commit. On GitHub and GitLab, the default branch is the branch the provider marks as default, often `main`. A push to any other branch does not update the graph. Branches named `dev` or `uat` are not indexed unless one of them is the default branch. A pull request does not build a second graph. Graphify keeps one graph per repository, and that graph is the default branch. A pull request is reviewed against that graph and the pull request's diff. See [Pull request reviews](/platform/reviews). There is no setting to index every branch, or to index on every pull request. To index a different line of development, make that branch the default branch on GitHub or GitLab. **Retry** on a failed build indexes the current head of the default branch. One index of a repository runs at a time. A later push to the default branch waits, or joins the build already queued. Hosted plans can also limit how many push-triggered indexes a repository finishes in a UTC day. A manual reindex does not use that allowance. The allowances are on [plans and pricing](/pricing/overview). The repository row can show **Out of date** when the newest default-branch commit is not the commit the graph is serving, and no build for that commit is running. ## Follow a build Open **Builds** and filter by repository or status. A build row identifies the repository, run state, and available timing or graph information. * For a queued or running build, use the available cancel control if you need to stop that attempt. * For a failed build, **Retry** starts indexing the repository's current head. It does not replay the historical failed commit. * If no rows match, clear the filters before concluding that the repository has never built. The first completed index makes code context available in [Graphs](/platform/graphs). [Wiki](/platform/wiki) is generated alongside the code graph when available for the workspace. ## Usage and access Respect the limit or provisioning message shown by the console. Hosted plans have daily push-build allowances as well as build concurrency and operational limits. Uncapped graph size on Pro and Teams does not remove those limits. See [plans and pricing](/pricing/overview) for hosted allowances, and the workspace's **Billing** view for its plan. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/repositories.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Frepositories) [PreviousProfile](/platform/profile) [NextConnect Google Drive](/platform/google-drive) # Pull request reviews Source: https://docs.graphify.com/platform/reviews [Cloud] Investigate review findings and understand the reach of a change. **Reviews** brings pull requests, findings, and code-graph context together in [Graphify Cloud](https://app.graphify.com). Use it to understand a change and the code it can affect. ## When a review runs Graphify reviews a pull request when it is opened, reopened, or marked ready for review. A draft is skipped until it is marked ready. A later push to the pull request does not start another review. To review the current head after new commits, a repository owner, member, or collaborator comments `@graphify review` on the pull request. The review uses the indexed default-branch graph plus that pull request's diff. It does not index the head branch. [Repositories and builds](/platform/repositories) explains which branch the graph follows. ## Turn reviews off On **Repositories**, open **Options** for the repository and switch **PR reviews** off. Automatic reviews stop, and `@graphify review` does not start one. Indexing stays on. Formal verification stays on until its own switch is turned off. ## Review a change 1. Open **Reviews** and choose the repository. 2. Select the relevant pull request and review run. Check the commit so you know which revision was analyzed. 3. Inspect the findings, source context, and affected code. Follow the pull request or commit link to investigate further. 4. Compare advisory findings with the run's verification evidence, where present. ![Graphify Cloud Reviews with pull request runs, findings, and affected code](https://graphify.com/assets/shots/reviews.webp) Graph context helps you look beyond the diff: callers, dependencies, and relationships can explain why a small edit has wider effects. ## Review and verification Advisory review findings and formal verification results answer different questions. A review can surface a concern to investigate. Verification compares supported changed functions. Read each label in [Formal verification](/platform/verification): proved equivalent, a behavior change, no divergence sampled, an abstention, or an error. Use the [Formal Verification](/platform/verification) view for the run history and per-function verdicts. Do not interpret a completed review as proof that all changed functions preserve behavior. ## Improve future reviews Give feedback on the pull request with `@graphify wrong `, `@graphify good `, or `@graphify suppress `. Use exact finding names from the review. The [Learn](/platform/learning) view shows learned dismissals, suppressed patterns, and feedback history. This adjusts advisory surfacing without changing verification verdicts. ## Repository review settings On **Repositories**, open **Options** for a repository. **PR reviews** turns the review bot on or off, as described above. These two switches are on unless you turn them off. Neither blocks a merge. * **Risky patterns** lists risky patterns on lines the pull request adds. The review can then include **Risky patterns (advisory)**. * **Stale docs** lists docs that mention code the pull request changed. The review can then include **Docs that may be stale (advisory)**. Expand the repository row to see **Unreferenced code (heuristic)**. It is not a switch. The card appears when indexing is on and the graph has nodes. It lists private functions, methods, and classes that nothing in that repository's graph references, and that a text search of the source finds no other use of. A symbol is listed only after it has stayed unreferenced for the number of days the card states, across at least two indexed builds. Code reached through reflection, a string lookup, or another repository can still appear, so check it before you remove it. ## Missing or outdated results Check the selected repository and commit, the settings above, and any plan-limit or access message. A result for an older commit describes that earlier revision. [Repositories and builds](/platform/repositories) explains where to check indexing and repository controls. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/reviews.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Freviews) [PreviousAgent memory](/platform/memory) [NextFormal verification](/platform/verification) # Trace who calls this Source: https://docs.graphify.com/platform/trace [Cloud] Find a symbol, who calls it, and whether two names connect. Use this when you know a name in the repository and want the code around it. Run the commands from the repository root after a map exists in `graphify-out/`, and replace `YourService` and `YourRepository` with names from your graph. ## Who calls this ```bash theme={null} graphify query "what calls YourService?" --context call graphify explain "YourService" ``` `--context call` keeps call relationships. `explain` prints one concept, its source, and its connections. In the [small example project](/guides/first-graph), asking what calls `normalize_email` prints: ```text theme={null} Graph: graphify-out/graph.json (4 nodes) | Traversal: BFS depth=2 | Start: ['normalize_email()'] | Context: call (explicit) | 3 nodes found NODE normalize_email() [src=app.py loc=L1 community=0] NODE find_user() [src=app.py loc=L5 community=0] NODE login() [src=app.py loc=L9 community=0] EDGE find_user() --calls [EXTRACTED context=call]--> normalize_email() at=app.py:L6 EDGE login() --calls [EXTRACTED context=call]--> find_user() at=app.py:L10 ``` Each `EDGE` line is one call and where it happens: `find_user()` calls `normalize_email()` on line 6 of `app.py`. `EXTRACTED` means the relationship was read from the source rather than inferred; see [edges and provenance](/concepts/provenance). Exact formatting can vary by release. ## Whether two names connect ```bash theme={null} graphify path "YourService" "YourRepository" ``` In the example project, `graphify path "login" "normalize_email"` prints: ```text theme={null} Shortest path (2 hops): login() --calls [EXTRACTED]--> find_user() --calls [EXTRACTED]--> normalize_email() ``` A path needs both nodes and a chain of edges between them. No path is not proof that the two are independent. Add `--undirected` when you want connectivity rather than a directional path. ## What a change can affect In [Graphify Cloud](https://app.graphify.com), open **Graphs**, search for the name, and inspect its neighbors. On a pull request, open **Reviews** and read the findings and the code the change can affect. A graph connection is evidence to investigate. It is not proof that behavior stayed the same. > **[Ask better graph questions](/guides/querying)** > > When to use query, path, and explain. > **[Query reference](/reference/query)** > > Every flag `graphify query` accepts. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/trace.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Ftrace) [PreviousConsole tour](/platform/console) [NextRead a review and a verdict](/platform/read-a-result) # Formal verification Source: https://docs.graphify.com/platform/verification [Cloud] Compare changed functions, inspect behavioral differences, and understand each verification verdict. Graphify Cloud includes **Formal Verification** as a core feature. It compares changed functions with their earlier implementations to determine whether behavior is preserved or whether a concrete input produces a different result. Open **Formal Verification** in [Graphify Cloud](https://app.graphify.com). Hosted plans include verification with different usage and concurrency allowances; see [plans and pricing](/pricing/overview). ## Inspect a verification run ## 1. Choose the repository Use the **Repository** filter or select **All repositories** to see workspace runs. ## 2. Open a run Check the pull request and commit, then expand the run to inspect its outcome and per-function results. A finished run can contain a mixture of outcomes. ## 3. Follow the evidence Inspect the source file, function, and verdict. For a behavior change, the detail can include the distinguishing input and the old and new values. An abstention or failure includes its reason when available. ## 4. Return to the change Use **Open pull request** or the commit link to investigate the implementation. When a run has finished, **Re-run verification** can queue another attempt; queued and running attempts cannot be rerun simultaneously. ## Understand the result | Result | What it means | | - | - | | **Proved equivalent (bounded)** / `equivalent` | The proof method established equivalence within its supported model or analysis bounds. | | **Behavior change** / `distinguished` | An input distinguishes the implementations. Inspect whether the witness was reproduced in the sandbox or remains unconfirmed. | | **No divergence sampled (not proven)** / `may_equivalent` | The exercised inputs showed no difference. This is empirical evidence, not a proof. | | **Abstained** / `unsupported` | The method could not analyze the function within its supported domain or budget. | | **Errored** / `error` | Verification failed to produce a valid result for the function. | **Completed** describes a run's lifecycle; it does not mean every function was proved equivalent. Queued, verifying, failed, cancelled, skipped, and expired runs also retain their own status. A run that verified no functions does not imply the change passed. ## Configure and use verification Repository controls include a **Formal verification** setting for pull requests. Use [Repositories and builds](/platform/repositories) to check repository configuration and indexing before investigating missing runs. When Graphify supplies a distinguishing input, use it to reproduce the difference and create a regression test. Review whether the changed behavior was intentional before deciding what to change. [Learning](/platform/learning) tunes advisory review feedback only. It cannot change proof verdicts or hide a witness from the verifier. ## Scope of a proof Verification is function-level and differential: the previous implementation is the reference. It does not establish that the application meets its intended requirements. Read bounds, unsupported cases, and reproduction status with the result. For the separately installed enterprise CLI, the website's [verification reference](https://graphify.com/docs/verification) documents `verify-edit` and gate configuration. Those commands are distinct from the hosted console workflow and the public open-source CLI. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/verification.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Fverification) [PreviousPull request reviews](/platform/reviews) [NextLearning](/platform/learning) # When something fails Source: https://docs.graphify.com/platform/when-stuck [Cloud] What to check for an empty graph, a failed build, or a plan limit. Match the message on screen, then open the page it points to. ## The map did not write graphify-out `/graphify .` is an assistant instruction, not a shell command. Run it in the assistant chat at the repository root. A finished map writes `graphify-out/graph.html`, `GRAPH_REPORT.md`, and `graph.json`. If the folder is missing, confirm the install: ```bash theme={null} graphify --version graphify install --platform cursor ``` You should see a version line, then a skill install for that assistant. More install failures are in [Troubleshooting](/troubleshooting). ## Cloud shows no graph Open **Repositories** and read the status. | Status | Meaning | | - | - | | Indexed | A graph has been built and is available. | | Building | Indexing is running. | | Queued | The repository is waiting to build. | | Failed | The latest attempt did not finish. | | Paused | Indexing is off. | [Repositories and builds](/platform/repositories) is where you connect the repository and turn indexing on. ## A build failed Open **Builds**, filter to that repository, and choose **Retry** on its latest failed build. On **Repositories**, a failed repository's **Options** also offer **Retry indexing**. Both index the repository's current head, not the commit that failed. ## You hit a plan limit The console names the limit: | Message | What it means | | - | - | | **Monthly indexing allowance used** | The workspace has used this month's indexing allowance. It resets at the start of next month. | | **Daily build limit reached** | This repository has used today's automatic builds. The limit resets at 00:00 UTC. | | **Repository too large for this plan** | The newest version was not published. The last published version still works. | | **Monthly reviews used** | The reviews included in the plan are used for this month. | Compare allowances on [Plans and pricing](/pricing/overview), and check the workspace **Billing** page for the plan in use. A limit message is not an empty repository. ## Still stuck Ask in [Discord](https://discord.gg/graphify), or open a [GitHub issue](https://github.com/Graphify-Labs/graphify/issues) for the open-source engine. Include the installed version, operating system, exact command, and a sanitized error. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/when-stuck.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Fwhen-stuck) [PreviousRead a review and a verdict](/platform/read-a-result) [NextRepository graphs](/platform/graphs) # Wiki Source: https://docs.graphify.com/platform/wiki [Cloud] Read, search, and ask questions about documentation generated from your repository graph. **Wiki** turns an indexed repository into browsable documentation connected to its code graph. Open **Wiki** in [Graphify Cloud](https://app.graphify.com), then select a repository. ## Read your repository's wiki Start with **Overview**, then use the article index to explore communities and concepts. The table of contents moves between sections of the current article. Links connect related articles and, where a graph reference can be resolved, open the corresponding code context in **Graphs**. The wiki is generated alongside the repository's code graph. Articles describe the indexed build, so check the repository's indexing state when comparing them with newer code. ## Search or ask The wiki provides two ways to investigate a question: | Mode | Use it for | | - | - | | **Search** | Find words and phrases inside article bodies. Results identify matching articles and highlight relevant text. | | **Ask** | Ask a question that needs connected code context, such as ownership, a call path, or where a behavior lives. | Search first when you know a name or phrase. Use **Ask the wiki instead** when you need an explanation across relationships. Open the referenced articles and graph nodes to inspect the evidence behind an answer. ## Share a useful page The current repository and article are reflected in the page URL. Copy that URL to direct a teammate to the same article. They need access to the corresponding Cloud workspace and repository. If the article no longer exists in the current build, the reader falls back to the wiki Overview. ## When the wiki is empty * **Repository not indexed**: enable indexing and let the next repository build finish. * **Indexing in progress**: the wiki appears with the completed code graph. * **No wiki artifact for an older build**: re-index the repository to produce a current wiki. Wiki availability depends on workspace access. If the page reports an unavailable or oversized artifact, follow its displayed message; that state is different from an empty search result. For graph navigation, see [Explore your graphs](/platform/graphs). For a local Markdown export, see [Export and reuse your graph](/guides/exports). [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/wiki.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Fwiki) [PreviousRepository graphs](/platform/graphs) [NextAgent memory](/platform/memory) # Graphify Enterprise Source: https://docs.graphify.com/pricing/enterprise [Both] An enterprise buyer's guide to Graphify: capabilities, self-hosting, security, identity, licensing, support, and evaluation. Graphify Enterprise gives engineering organizations a shared knowledge graph of their software, with graph-aware pull request review and formal verification running in infrastructure they control. It is for teams that need to understand dependencies across repositories, give coding agents grounded context, and meet enterprise deployment and procurement requirements. > [!NOTE] > > Enterprise is in **early access**. Deployment, enabled capabilities, capacity, and commercial terms are scoped with your account team before rollout. ## At a glance | Area | Enterprise offering | | - | - | | Deployment | Self-hosted on your infrastructure; discuss BYOC, VPC, on-premises, or air-gapped requirements. | | Licensing | Per developer seat, with a custom quote and renewal terms. | | Repositories | Unlimited; deployment capacity is scoped with your account team. | | Identity | SSO/SAML; identity-provider setup is part of deployment planning. | | Code host | GitHub Enterprise support. | | Core workflows | Repository knowledge graphs, graph-aware PR review, and function-level formal verification. | | Support | Dedicated Slack support channel. | | Procurement | Custom invoicing and payment terms, DPA, and terms of service. | > **[Discuss your deployment](https://graphify.com/enterprise)** > > Share your team size, infrastructure, and workflows with the enterprise team. > **[Compare all plans](/pricing/overview)** > > Compare Enterprise with the hosted Free, Pro, and Teams plans. ## What your team can do ### Understand the codebase as a graph Graphify connects code symbols, dependencies, and repositories so a developer or agent can follow relationships instead of reconstructing them from isolated search results. Use the graph to investigate a call path, understand the reach of a change, and navigate shared code across services. The graph foundation is shared with the open-source engine. Enterprise adds the deployment and organizational capabilities around that foundation. See [how Graphify works](/concepts/architecture) and [graph provenance](/concepts/provenance). ### Review changes with dependency context Graph-aware PR review looks beyond the changed lines to the code that calls, depends on, or overlaps with them. Teams can inspect findings alongside the affected code and use that context in their existing review workflow. Review findings are advisory analysis. They should be assessed alongside tests, code review, and the evidence attached to each result. See [pull request reviews](/platform/reviews). ### Verify behavior changes Formal verification compares changed functions with their earlier implementations. Results can include a proof within the supported model, a distinguishing input that demonstrates different behavior, or an explicit unsupported or failed outcome. A completed run is not a blanket proof that an application is correct. Inspect analysis bounds, per-function verdicts, and whether a reported witness was reproduced. See [formal verification](/platform/verification) for the result types and their meaning. ### Give people and agents shared context The Graphify product also includes the following workflows. Review the required feature set with your account team for your Enterprise deployment, especially when planning a restricted-network environment. | Workflow | What it provides | | - | - | | [Repository graphs](/platform/graphs) | Explore symbols, dependencies, communities, and relationships across repositories. | | [Wiki](/platform/wiki) | Browse and search documentation generated from an indexed repository, and ask grounded questions. | | [Learning](/platform/learning) | Use trusted review feedback to reduce repetitive advisory findings. Learning does not change formal proof verdicts or hide verifier witnesses. | | [Agent memory](/platform/memory) | Retain useful facts with grounding and provenance for later agent work. | | [Coding-agent connections](/platform/connections) | Make graph context available to assistants through MCP. | | [Buildkite test selection](/integrations/buildkite) | Use changed-code context to select affected tests in enabled workspaces, with full-suite fallback. | These product guides describe the Cloud workflow. Your deployment's configuration determines which integrations and UI flows are enabled. ## Deployment and infrastructure ### Self-hosting and network boundaries Enterprise is the commercial offering for running Graphify on your own infrastructure. The [enterprise offering](https://graphify.com/enterprise) includes BYOC and air-gapped VPC deployment discussions; on-premises and VPC requirements can be included in the access request. In a self-hosted deployment, ingested code and graph data stay in your infrastructure. Plan the complete data path, including code hosts, identity providers, model endpoints, connected assistants, and CI systems. An external coding assistant remains subject to its own configuration and provider terms. For an air-gapped deployment, agree the supported feature set, local dependencies, update process, and integration paths before rollout. A hosted connector recipe alone is not an air-gap deployment guide. ### Capacity and operations Sizing depends on the repositories you index, graph size, change volume, review and verification concurrency, and enabled features. Bring those requirements to deployment planning rather than treating the hosted plan allowances as Enterprise capacity guarantees. Define responsibility for infrastructure, upgrades, backups, recovery, and monitoring during scoping. Any required availability target, recovery objective, or maintenance window should be part of that discussion. ### Enterprise, Cloud, and the open-source engine | Option | Use it when | | - | - | | **Graphify Enterprise** | You need the enterprise product and commercial support in an agreed self-hosted environment. | | **Graphify Cloud** | You want Graphify to host your workspace on Free, Pro, or Teams. | | **Open-source engine** | You want the Apache 2.0 CLI and local graph workflow without an account or paid license. | Running the open-source engine locally does not require an Enterprise license. See the [local setup guide](/guides/local-development). ## Security, privacy, and identity ### Data ownership and model training You own the code and content you ingest, and the graphs built from them. Graphify treats ingested content as confidential and does **not train models on your code**. See the [Terms of Service](https://graphify.com/terms) and [Privacy Policy](https://graphify.com/privacy). The hosted service uses subprocessors, including OpenAI and Anthropic for inference under their API terms. Self-hosted data handling is distinct from the hosted service; review the [subprocessor list](https://graphify.com/subprocessors) and agree the model and network configuration for your deployment. Independently connected assistants can send prompts or retrieved context to their own providers. ### SSO and access Enterprise includes **SSO/SAML** and **GitHub Enterprise support**. During setup, identify your identity provider, code-host installation, workspace administrators, and the repositories users should access. Validate the intended access boundaries with representative users before expanding the rollout. Workspace membership and administrative actions are permissioned. The Graphify workspace provides **Members**, **Settings**, and **Billing** controls where available; repository and integration setup may require an owner or administrator. Confirm your provisioning and offboarding requirements during evaluation. ### Compliance and audit evidence Graphify's **SOC 2 Type II engagement has started; no report is available yet**. Exportable audit logs are also described as part of the Enterprise early-access track. Review the current [Security page](https://graphify.com/security) and [Trust Center](https://trust.graphify.com) for updates and available evidence. Bring required encryption standards, audit exports, certifications, and security questionnaires to the evaluation. Confirm the controls and evidence for the proposed deployment instead of assuming that an in-progress control is already delivered. ### Retention, export, and deletion On self-hosted deployments, retention is governed by your own infrastructure. Agree how graph storage, backups, logs, and deletion should work with your internal policy. The [Privacy Policy](https://graphify.com/privacy) documents hosted retention separately and explains how to request export or deletion. A **DPA is available**, with custom terms supported for Enterprise. ## Licensing and commercial terms Enterprise is licensed **per developer seat** with custom pricing. The quote is scoped with your account team, rather than purchased through the self-service checkout. The enterprise offering supports: * Custom invoicing and payment terms. * A custom DPA and terms of service. * Deployment and capacity scoped to your organization. * License renewal and seat arrangements agreed with your account team. Include your expected developer count and growth, deployment footprint, required capabilities, and procurement timeline when requesting a quote. Confirm seat definitions, minimum commitments, capacity, renewal, and any third-party or infrastructure costs in the proposal. There is no public fixed Enterprise price or universal hardware specification. ## Support and rollout Both Teams and Enterprise include a **dedicated Slack support channel**. If you require specific response times, coverage hours, an escalation process, onboarding services, or an availability SLA, agree them during procurement. The public plan does not specify a universal SLA. Use the following evaluation sequence to align engineering, security, and procurement: ## 1. Scope the deployment Share team size, repository hosts, infrastructure, network restrictions, and the workflows you want to evaluate. Identify engineering and security owners. ## 2. Agree the evaluation Choose representative repositories and define success measures, such as graph coverage, review usefulness, verification outcomes, or agent access. Confirm available features and capacity. ## 3. Validate with a pilot team Connect the agreed repositories and identity configuration. Exercise indexing, review, verification, and agent access. Check unsupported outcomes and access boundaries as well as successful results. ## 4. Complete procurement and plan expansion Resolve the security review, DPA, license, support expectations, and operating responsibilities. Agree the rollout sequence and ownership before adding more teams. ## Prepare for an enterprise discussion | Bring | Why it helps | | - | - | | Developer count and expected growth | Scopes seats and rollout phases. | | Code hosts, repository count, languages, and approximate sizes | Establishes integration and indexing requirements. | | PR volume and verification or CI workflows | Helps plan workload and concurrent capacity. | | Cloud provider or on-premises environment, regions, and network restrictions | Defines deployment, connectivity, and data-residency requirements. | | Identity provider and access requirements | Scopes SSO, administration, and offboarding. | | Security questionnaire, audit needs, retention policy, and DPA requirements | Gives your reviewers a concrete list of controls and evidence to assess. | | Target timeline, budget process, and support requirements | Aligns the evaluation and commercial proposal. | ## Frequently asked questions > **Do we need Enterprise to use formal verification?** > > No. Hosted Graphify plans also include formal verification with plan-specific allowances. Enterprise is the option for an agreed self-hosted deployment, enterprise identity, support, and commercial terms. See [plans and pricing](/pricing/overview). > **Can we use our existing coding assistants?** > > Graphify connects through MCP to clients including Claude Code, Cursor, Codex, and GitHub Copilot. Your assistant and model-provider policies still apply. Confirm the client, identity flow, and network path for your deployment. See [agent integrations](/integrations/overview). > **Is GitHub Enterprise supported?** > > Yes. Include your GitHub Enterprise deployment and connectivity requirements when scoping Enterprise. For other code hosts and integrations, confirm the required workflow with the account team. > **Is an Enterprise trial the same as the two-week hosted trial?** > > No automatic Enterprise trial terms are published. Pro and Teams offer a two-week hosted trial; an Enterprise evaluation is arranged with the account team. > **Can we complete a security review before signing?** > > Share your questionnaire and required evidence with the team during evaluation. The [Security page](https://graphify.com/security), [Privacy Policy](https://graphify.com/privacy), [subprocessors](https://graphify.com/subprocessors), and [Trust Center](https://trust.graphify.com) are the starting points. SOC 2 Type II remains in progress. > **[Talk to Graphify about Enterprise](https://graphify.com/enterprise)** > > Start an enterprise access request with your team size and requirements. You can also reach the team through graphify.com/contact. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/pricing/enterprise.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fpricing%2Fenterprise) [PreviousPlans and pricing](/pricing/overview) # Plans and pricing Source: https://docs.graphify.com/pricing/overview [Both] Compare Free, Pro, Teams, and Enterprise, including pricing, usage allowances, billing, and deployment options. Graphify offers hosted plans for individual developers and teams, and a separately scoped Enterprise offering for organizations that need their own deployment and commercial terms. > [!NOTE] > > Prices and hosted allowances below match the current [pricing plans](https://graphify.com/pricing), updated October 8, 2026. Check your workspace's **Billing** page and checkout for the plan and offer available to you. Enterprise pricing and capacity are agreed with your account team. ## Choose a plan | Plan | Best fit | Where it runs | | - | - | - | | **Free** | One developer getting started, with no card required. | Graphify Cloud | | **Pro** | One developer who needs uncapped graphs and higher build, review, and verification limits. | Graphify Cloud | | **Teams** | A team sharing repository graphs, central billing, and a dedicated Slack support channel. Minimum 2 seats. | Graphify Cloud | | **Enterprise** | An organization requiring self-hosting, enterprise identity, GitHub Enterprise, and negotiated terms. | Your infrastructure; deployment scoped with Graphify | The [open-source CLI](/quickstart) is a separate, free Apache 2.0 tool. It runs locally without a Graphify account. A hosted subscription is not required to use it. ## Subscription prices All prices below are in USD. Annual prices are monthly equivalents; the annual amount is charged once per year. | Plan | Monthly billing | Annual billing | | - | - | - | | **Free** | \$0 | \$0 | | **Pro** | \$15/month | \$10/month equivalent (\$120/year) | | **Teams (first 100 teams offer)** | \$29/seat/month | \$20/seat/month equivalent (\$240/seat/year) | | **Teams (standard price)** | \$40/seat/month | \$28/seat/month equivalent (\$336/seat/year) | | **Enterprise** | Custom quote | Custom quote | Teams requires at least **2 seats**. At the introductory annual rate, that is \$480/year for two seats; at the standard annual rate, it is \$672/year. Availability of the first-100-teams offer is confirmed at checkout. Pro and Teams include a **two-week trial**, with a card required to start. Free has no card requirement. ## Hosted plan allowances Usage is counted at the scope shown in each row. Workspace allowances are shared across the workspace; the pricing page does not describe them as a separate allowance for every purchased seat. | Allowance | Free | Pro | Teams | | - | - | - | - | | Repositories | 3 | Unlimited | Unlimited shared | | Graph nodes per repository | 25,000 | Uncapped | Uncapped | | Push-triggered graph builds per repository | 10/day | 100/day | 100/day | | PR reviews per workspace | 15/month | 400/day | 700/day | | Concurrent PR reviews | 2 | 10 | 20 | | Formal verification runs per workspace | 1/day | 400/day | 800/day | | Concurrent formal verification runs | 1 | 2 | 2 | **Uncapped** applies to graph size on Pro and Teams. Build, review, verification, and operational limits still apply. Pro also includes deep reading of your documents. Teams adds shared graphs, centralized billing, and a **dedicated Slack support channel**. See the [Cloud overview](/platform/overview) for graphs, Wiki, reviews, formal verification, Learning, and agent memory. ### Build concurrency All hosted plans allow **1 index build at a time per repository** and **10 across a workspace**. PR reviews and formal verification runs have the plan-specific concurrency limits shown above. ### Shared operational limits The published hosted plans also have the following limits: | Operation | Limit | | - | - | | Memory ingestion | 2,000 ingests/day | | Stored memory | 10,000 turns/repository | | Memory consolidation | 1 concurrent job/workspace | | Ask requests | 30/minute | | Query requests | 120/minute | | MCP requests | 240/minute | If an operation reaches a limit, follow the message in the console. For higher capacity or a different deployment model, [discuss Enterprise](https://graphify.com/enterprise) with the team. ## Enterprise Enterprise includes unlimited repositories and combines the graph workflow with **self-hosting, SSO/SAML, GitHub Enterprise support, formal verification, graph-aware PR review, and a dedicated Slack support channel**. It also supports custom invoicing, payment terms, a DPA, and terms of service. Licensing is **per developer seat**. Deployment, capacity, and pricing are scoped with your account team. Enterprise is currently in **early access**. > **[Graphify Enterprise](/pricing/enterprise)** > > A guide for engineering, security, and procurement teams: capabilities, deployment, data handling, licensing, and evaluation. ## Dedicated Slack support Both **Teams** and **Enterprise** include a **dedicated Slack support channel**. | Plan | Included support | | - | - | | **Teams** | Dedicated Slack support channel. | | **Enterprise** | Dedicated Slack support channel; any additional support commitments are agreed with your account team. | ## Billing and subscription management Open **Billing** in your [Graphify Cloud workspace](https://app.graphify.com) to review the current plan, seats, billing interval, and renewal information. Use its billing portal for payment details, invoices, and cancellation. Billing actions depend on your workspace permissions. Paid subscriptions renew until cancelled. Under the standard [Terms of Service](https://graphify.com/terms), cancellation takes effect at the end of the current billing period, and paid fees are non-refundable except where required by law. Review the confirmation shown when changing a plan or seat count. Enterprise invoicing and changes follow the agreement with your account team. ## Open-source and startup programs > **[Open-source projects](https://graphify.com/oss)** > > Qualified non-commercial projects with MIT or Apache licenses can apply for free Graphify access. > **[Early-stage startups](https://graphify.com/startups)** > > Pre-Seed and Seed startups with under \$1M in revenue over the past 12 months can apply for 50% off Teams for up to 6 months. ## Common questions ### Do I need Enterprise for formal verification? No. Formal verification is also part of Graphify Cloud, with the hosted allowances listed above. Enterprise adds the deployment, identity, support, and commercial arrangements described in the [enterprise guide](/pricing/enterprise). ### Should we choose Teams or Enterprise? Choose Teams for a hosted workspace with shared graphs, central billing, and a dedicated Slack support channel. Discuss Enterprise if you need your own infrastructure, SSO/SAML, GitHub Enterprise support, or negotiated procurement terms. ### Does buying more seats increase every usage limit? The listed allowances have repository, workspace, and request scopes. Do not multiply workspace limits by seat count. Confirm any additional capacity with Graphify before planning a larger rollout. ### Where do we start? Create a [Cloud account](https://app.graphify.com) to start Free or a paid trial. For self-hosting and enterprise requirements, [contact the enterprise team](https://graphify.com/enterprise). [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/pricing/overview.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fpricing%2Foverview) [NextGraphify Enterprise](/pricing/enterprise) # Your first knowledge graph Source: https://docs.graphify.com/quickstart [Local] Install Graphify, map your repository, and ask a question about your code. Graphify turns a repository into a graph of its functions, classes, imports, and relationships. Your assistant can query that graph instead of repeatedly scanning the same files. This quickstart uses the **open-source engine** on your machine. You need Python 3.10 or later and a supported coding assistant. For the hosted product, see [Graphify Cloud](/platform/overview). > [!NOTE] > > If you are an agent, read [Notes for agents](/for-agents) before these steps. ## 1. Install the CLI On a Mac, use the macOS tab. The version check is the same on every tab. ```bash macOS theme={null} brew install uv uv tool install graphifyy graphify --version ``` ```bash uv theme={null} uv tool install graphifyy graphify --version ``` ```bash pipx theme={null} pipx install graphifyy graphify --version ``` `graphify --version` prints the version you installed. The latest release is on [PyPI](https://pypi.org/project/graphifyy/) and in the [changelog](/changelog). The package is **`graphifyy`**, with two y's. The command is `graphify`. A virtual environment install is on [Installation](/installation). ## 2. Connect your assistant ```bash theme={null} graphify install ``` This installs the Graphify skill for a detected assistant. To choose one explicitly: ```bash theme={null} graphify install --platform cursor ``` See [all integrations](/integrations/overview) for your assistant’s setup. ## 3. Map a repository Open a repository in your assistant, then enter this in its chat: ```text theme={null} /graphify . ``` In Codex, select the Graphify skill with `$graphify` and ask it to map the current repository. This is an **assistant instruction**, not a shell command. Code is parsed locally. If the repository includes documents or media, the skill can use your assistant’s model for semantic extraction. For an explicit code-only run, use the [local CLI workflow](/guides/local-development). ## 4. Inspect the output ```text theme={null} graphify-out/ ├── graph.html Interactive graph ├── GRAPH_REPORT.md Concepts, communities, and suggested questions └── graph.json The graph used by CLI and MCP queries ``` Open `graph.html` in your browser. Click a node to inspect its connections, or start with the report for a tour of the architecture. ## 5. Ask a question From a terminal at the repository root: ```bash theme={null} graphify query "how does authentication reach the database?" ``` Use names from **your graph** to investigate further: ```bash theme={null} graphify explain "YourService" graphify path "YourService" "YourRepository" ``` The names above are placeholders. A path only exists if those nodes and connecting edges exist in your project. > **[Take the full tutorial](/guides/first-graph)** > > Build a small example and follow a real relationship. > **[Give your agent MCP tools](/mcp/overview)** > > Expose the graph as structured tools in your editor. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/quickstart.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fquickstart) [PreviousOverview](/) [NextInstallation](/installation) # Configuration Source: https://docs.graphify.com/reference/configuration [Local] Configure model backends, output paths, and local logging. Code-only extraction works without a provider key. These backend settings matter when you explicitly run semantic extraction or model-assisted CLI workflows. ## Semantic backends | `--backend` | Main configuration | Optional package extra | | - | - | - | | `claude` | `ANTHROPIC_API_KEY`; optional `ANTHROPIC_BASE_URL`, `ANTHROPIC_MODEL` | `anthropic` | | `gemini` | `GEMINI_API_KEY` or `GOOGLE_API_KEY` | `gemini` | | `openai` | `OPENAI_API_KEY`; optional `OPENAI_BASE_URL`, `OPENAI_MODEL` | `openai` | | `deepseek` | `DEEPSEEK_API_KEY` | Use the client dependency required by your version. | | `kimi` | `MOONSHOT_API_KEY` | `kimi` | | `ollama` | Optional `OLLAMA_BASE_URL`, `OLLAMA_MODEL` | `ollama` | | `bedrock` | Standard AWS credential chain | `bedrock` | | `azure` | `AZURE_OPENAI_API_KEY`, `AZURE_OPENAI_ENDPOINT`, deployment setting | `openai` | | `claude-cli` | Installed and authenticated Claude Code CLI | No separate model API key. | Set credentials in your shell, secret manager, or CI environment. Never commit them into the documentation or repository. Use a model available in your account or local runtime rather than assuming a particular model name. ## Output and resource controls | Variable | Meaning | | - | - | | `GRAPHIFY_OUT` | Output directory, useful for separate worktrees. | | `GRAPHIFY_MAX_WORKERS` | Structural extraction worker count. | | `GRAPHIFY_MAX_OUTPUT_TOKENS` | Semantic model output cap. | | `GRAPHIFY_API_TIMEOUT` | Backend request timeout in seconds. | | `GRAPHIFY_MAX_RETRIES` | Retry count for rate-limited requests. | | `GRAPHIFY_MAX_RETRY_DEPTH` | Limit recursive recovery of truncated chunks. | | `GRAPHIFY_MAX_GRAPH_BYTES` | Override the graph file size guard; default is 512 MiB. | | `GRAPHIFY_API_KEY` | Authentication for a shared graph MCP HTTP server. | | `GRAPHIFY_TRIAGE_BACKEND` / `GRAPHIFY_TRIAGE_MODEL` | Backend and model for CLI PR triage. | ## Local query logging The current implementation keeps query logging **off by default**. | Variable | Effect | | - | - | | `GRAPHIFY_QUERY_LOG_ENABLE=1` | Enable a local JSONL query log at `~/.cache/graphify-queries.log`. | | `GRAPHIFY_QUERY_LOG=/path/to/log` | Enable logging to a chosen file. | | `GRAPHIFY_QUERY_LOG_DISABLE=1` | Force logging off, overriding enable settings. | | `GRAPHIFY_QUERY_LOG_RESPONSES=1` | Include full responses when logging is enabled. | Logs can contain questions and corpus paths. Full responses are opt-in. Keep access and retention appropriate to your source material. ## Ignore rules Use `.graphifyignore` to exclude dependency folders, build artifacts, or irrelevant content. See [incremental updates](/guides/incremental-updates) for examples. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/reference/configuration.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Freference%2Fconfiguration) [Previousgraphify extract](/reference/extract) [NextMCP tool reference](/reference/mcp-tools) # graphify explain Source: https://docs.graphify.com/reference/explain [Local] Inspect a concept, its source, and the relationships around it. ```bash theme={null} graphify explain "" [--graph ] ``` Give the command a label or node identifier from a query result. It returns details about the node and its graph context. ```bash theme={null} graphify explain "normalize_email" graphify explain "YourNodeId" --graph ./shared/graph.json ``` Look for the source file, community, and relationships connected to the node. Available fields depend on the extractor. If several concepts have similar names, use the precise ID returned by the graph. Optional [work-memory](/guides/work-memory) overlays can add lesson hints. Check for stale-source warnings and re-verify a lesson after code changes. For native MCP access, use `get_node` followed by `get_neighbors` when you need the surrounding edges. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/reference/explain.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Freference%2Fexplain) [Previousgraphify path](/reference/path) [Nextgraphify extract](/reference/extract) # graphify extract Source: https://docs.graphify.com/reference/extract [Local] Run local structural extraction and optional semantic processing. ```bash theme={null} graphify extract [options] ``` ## Common options | Option | Purpose | | - | - | | `--code-only` | Skip semantic document and media extraction; no model key needed. | | `--backend ` | Select a headless semantic backend. | | `--model ` | Override the model for that backend. | | `--mode deep` | Request richer semantic extraction. | | `--out ` / `--output ` | Choose an output root. | | `--no-cluster` | Skip clustering. | | `--no-gitignore` | Ignore Git’s exclusions while still honoring `.graphifyignore`. | | `--max-workers ` | Structural extraction parallelism. | | `--token-budget ` | Semantic chunk budget. | | `--max-concurrency ` | Concurrent model requests. | | `--api-timeout ` | Request timeout. | | `--force` | Permit replacement with a smaller graph after intentional changes. | | `--timing` | Print stage timings. | | `--google-workspace` | Explicitly enable Google Workspace shortcut export. | | `--cargo` | Include Cargo workspace dependency information. | | `--postgres ` | Read a PostgreSQL schema with the relevant extra and credentials. | ## Examples ```bash theme={null} graphify extract . --code-only graphify extract ./docs --backend ollama --max-concurrency 2 graphify extract ./src --code-only --timing ``` ## Outputs and failures Inspect the console summary and generated report before using the graph. Missing grammars, unsupported files, model errors, partial results, and the smaller-graph guard can affect what was written. `--force` is an explicit override, not a routine remedy for an unexplained failure. See [headless extraction](/guides/headless-extraction) for provider setup and [outputs](/concepts/outputs) for the saved files. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/reference/extract.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Freference%2Fextract) [Previousgraphify explain](/reference/explain) [NextConfiguration](/reference/configuration) # MCP tool reference Source: https://docs.graphify.com/reference/mcp-tools [Local] Inputs for all ten Graphify graph and pull request tools. The current graph MCP server exposes ten tools. Connect it with the [MCP setup guide](/mcp/overview). Every tool also accepts an optional `project_path`: an absolute path to a project directory containing `graphify-out/graph.json`. Omit it to use the graph selected when the server started. Access is subject to the server’s path controls. These schemas were extracted from the audited `graphify/serve.py` source. Graph exploration returns saved evidence. PR tools additionally use GitHub context; MCP triage returns data for your assistant to reason over. ## query\_graph Search the knowledge graph using BFS or DFS. Returns relevant nodes and edges as text context. | Input | Type | Required | Default / description | | - | - | - | - | | `question` | `string` | Yes | Natural language question or keyword search | | `mode` | `string` | No | Default: `"bfs"`. bfs=broad context, dfs=trace a specific path Values: `bfs`, `dfs`. | | `depth` | `integer` | No | Default: `3`. Traversal depth (1-6) | | `token_budget` | `integer` | No | Default: `2000`. Max output tokens | | `context_filter` | `array` | No | Optional explicit edge-context filter, e.g. \['call', 'field'] | ## get\_node Get full details for a specific node by label or ID. | Input | Type | Required | Default / description | | - | - | - | - | | `label` | `string` | Yes | Node label or ID to look up | ## get\_neighbors Get all direct neighbors of a node with edge details. | Input | Type | Required | Default / description | | - | - | - | - | | `label` | `string` | Yes | Optional. | | `relation_filter` | `string` | No | Optional: filter by relation type | | `token_budget` | `integer` | No | Default: `2000`. Max output tokens | ## get\_community Get all nodes in a community by community ID. | Input | Type | Required | Default / description | | - | - | - | - | | `community_id` | `integer` | Yes | Community ID (0-indexed by size) | | `token_budget` | `integer` | No | Default: `2000`. Max output tokens | ## god\_nodes Return the most connected nodes - the core abstractions of the knowledge graph. | Input | Type | Required | Default / description | | - | - | - | - | | `top_n` | `integer` | No | Default: `10`. | | `exclude_hubs_percentile` | `number` | No | Suppress nodes whose degree exceeds this percentile (0-100) of the degree distribution, matching cluster()'s hub exclusion | ## graph\_stats Return summary statistics: node count, edge count, communities, confidence breakdown. No required inputs. Call with `{}` for the default graph. ## shortest\_path Find the shortest path between two concepts in the knowledge graph. Follows stored edge direction by default; set undirected=true to ignore it. | Input | Type | Required | Default / description | | - | - | - | - | | `source` | `string` | Yes | Source concept label or keyword | | `target` | `string` | Yes | Target concept label or keyword | | `max_hops` | `integer` | No | Default: `8`. Maximum hops to consider | | `undirected` | `boolean` | No | Default: `false`. Ignore stored edge direction when searching | ## list\_prs List open GitHub PRs with CI status, review state, and graph impact (which communities each PR touches, blast radius). Use this before starting work to check if a PR already covers the area you're about to change. | Input | Type | Required | Default / description | | - | - | - | - | | `base` | `string` | No | Base branch to filter PRs by (auto-detected if omitted) | | `repo` | `string` | No | GitHub repo (owner/repo). Defaults to current repo. | ## get\_pr\_impact Get detailed graph impact for a specific PR: which files it changes, which knowledge-graph communities are affected, and how many nodes are touched. Use this to assess merge risk or check for overlap with your current work. | Input | Type | Required | Default / description | | - | - | - | - | | `pr_number` | `integer` | Yes | PR number to analyse | | `repo` | `string` | No | GitHub repo (owner/repo). Defaults to current repo. | ## triage\_prs Return all actionable open PRs (correct base, not stale) with full graph impact data so you can reason about review priority, merge order, and conflict risk. Call this when the user asks 'what PRs should I review?' or 'what's ready to merge?' | Input | Type | Required | Default / description | | - | - | - | - | | `base` | `string` | No | Base branch to filter PRs by (auto-detected if omitted) | | `repo` | `string` | No | GitHub repo (owner/repo). Defaults to current repo. | ## Example calls ```json query_graph theme={null} {"question": "request validation", "mode": "bfs", "token_budget": 1500} ``` ```json shortest_path theme={null} {"source": "login", "target": "normalize_email", "max_hops": 8} ``` The second example uses the [tutorial project](/guides/first-graph). Replace labels with nodes from your graph. A returned path is source-level context, not proof of runtime execution. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/reference/mcp-tools.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Freference%2Fmcp-tools) [PreviousConfiguration](/reference/configuration) # CLI reference Source: https://docs.graphify.com/reference/overview [Local] Find the command for building, exploring, exporting, and maintaining a graph. The package is `graphifyy`; the CLI is `graphify`. Run commands from your project root unless you provide an explicit graph path. ## Core commands | Command | Purpose | | - | - | | `graphify install` | Register the assistant skill. | | [`graphify extract`](/reference/extract) | Run the extraction pipeline. | | [`graphify query`](/reference/query) | Retrieve context around a question. | | [`graphify path`](/reference/path) | Follow a path between concepts. | | [`graphify explain`](/reference/explain) | Inspect one node. | | `graphify affected ""` | Inspect dependent impact using selected relations and depth. | | `graphify god-nodes` | Find highly connected nodes. | | `graphify diagnose` | Inspect graph quality and diagnostics. | | `graphify tree` | View graph-related project structure. | ## Maintenance and exports | Command | Guide | | - | - | | `graphify update .`, `graphify watch .`, `graphify check-update .` | [Incremental updates](/guides/incremental-updates) | | `graphify hook install`, `graphify hook status`, `graphify hook uninstall` | [Team workflows](/guides/team-workflows) | | `graphify cluster-only .`, `graphify label .` | [Architecture](/concepts/architecture) | | `graphify export ` | [Exports](/guides/exports) | | `graphify prs` | [Pull requests](/guides/pull-requests) | | `graphify save-result`, `graphify reflect` | [Work memory](/guides/work-memory) | ## Multiple graphs ```bash theme={null} graphify merge-graphs first.json second.json --out combined.json graphify global add graphify-out/graph.json --as my-project graphify global list graphify global path ``` Choose a unique project name when registering a graph globally. `graphify global remove my-project` removes that registration. ## Skill syntax is different `/graphify .` is an instruction to your coding assistant. `graphify extract . --code-only` is a shell command. Use the [integration guide](/integrations/overview) for your client’s skill invocation. ## Version scope This reference was checked against source version **0.9.62** on the repository’s `v8` branch. Check your installed version with `graphify --version`; flags and coverage can differ across releases. [Current source](https://github.com/Graphify-Labs/graphify). [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/reference/overview.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Freference%2Foverview) [Nextgraphify query](/reference/query) # graphify path Source: https://docs.graphify.com/reference/path [Local] Trace the shortest relationship path between two graph concepts. ```bash theme={null} graphify path "" "" [--graph ] [--directed | --undirected] ``` | Argument | Meaning | | - | - | | Source and target | Node labels, IDs, or matching keywords. | | `--graph` | Use a specific JSON graph. | | `--directed` | Respect stored direction; this is the current default. | | `--undirected` | Explore connectivity while ignoring direction. | The direction flags are mutually exclusive. ```bash theme={null} graphify path "login" "normalize_email" graphify path "normalize_email" "login" --undirected ``` These examples use the [tutorial project](/guides/first-graph). In another repository, use its actual labels or IDs. ## Interpret the path Follow each relationship and check its evidence. A source-level path does not prove that a particular runtime input executes it. An absent path can mean missing or unresolved relationships; it does not prove independence. For the MCP version, use `shortest_path`. Its inputs additionally expose `max_hops`; see the [MCP reference](/reference/mcp-tools). [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/reference/path.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Freference%2Fpath) [Previousgraphify query](/reference/query) [Nextgraphify explain](/reference/explain) # graphify query Source: https://docs.graphify.com/reference/query [Local] Retrieve a compact neighborhood of graph evidence for a question. ```bash theme={null} graphify query "" [--dfs] [--context ] [--budget ] [--graph ] ``` | Argument | Default | Meaning | | - | - | - | | Question | Required | Natural-language question or keywords. | | `--dfs` | Off | Use depth-first traversal instead of breadth-first. | | `--context` | No explicit filter | Filter edge context, such as `call`; repeat for multiple contexts. | | `--budget` | `2000` | Approximate output token budget. | | `--graph` | `graphify-out/graph.json` | JSON graph to query. | ```bash theme={null} graphify query "request validation" --budget 1500 graphify query "database access" --dfs --context call graphify query "entry points" --graph ./shared/graph.json ``` The response is graph context, not an independently verified natural-language answer. Review returned nodes, relations, provenance, and source references. Use [explain](/reference/explain) or [path](/reference/path) to narrow the result. ## Empty results Check the graph path and refresh changed source. Try a concrete function, class, or subsystem name. The graph can only return relationships present in the analyzed inputs. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/reference/query.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Freference%2Fquery) [PreviousCLI reference](/reference/overview) [Nextgraphify path](/reference/path) # Troubleshooting Source: https://docs.graphify.com/troubleshooting [Both] Resolve common installation, graph, and MCP connection problems. > **The graphify command is not found** > > Run `uv tool update-shell` or `pipx ensurepath`, then open a new terminal. Verify that the package you installed was `graphifyy`. A GUI app may need an absolute executable path even when your terminal finds it. > **Python cannot import graphify or mcp** > > Your command may be using a different Python environment. Install the `mcp` extra in the environment that launches the server, or use the `graphify-mcp` executable from the uv tool installation. See [MCP setup](/mcp/overview). > **My assistant does not discover the skill** > > Register the exact platform with `graphify install --platform `. Confirm whether you intended a user or project installation. Refresh the assistant’s skills or restart it. In Codex, use the skill picker; not every client has the same slash-command behavior. > **graph.json does not exist** > > Run the build workflow before querying. For a local test, use `graphify extract . --code-only` at the project root. For another location, pass `--graph /absolute/path/to/graph.json` to queries and the absolute path to MCP. > **The answer reflects old code** > > Run `graphify update .`, then query again. Git hooks run in the background, and pulls/merges require an explicit update. Refresh document context through the skill or semantic extraction if documents changed. > **A refresh refuses to write a smaller graph** > > Inspect the warning and confirm the smaller result is intentional. Missing dependencies or failed semantic calls can produce incomplete output. After an intentional removal or refactor, use `graphify update . --force` to allow replacement. > **A query returns no path** > > Check the node names and graph version. Paths respect stored direction by default; try `--undirected` only if you want general connectivity. Missing edges can reflect unresolved or unsupported code, not necessarily the absence of a relationship. > **Local model extraction is slow or runs out of memory** > > Lower `--token-budget` and `--max-concurrency`. Check that the chosen model supports the input and output size. Adjust `GRAPHIFY_OLLAMA_NUM_CTX` only with the local model’s memory needs in mind. > **The MCP server disconnects or shows no tools** > > Run its configured command manually and inspect stderr. Check the MCP extra, executable path, and graph path. Refresh the client after changes. For HTTP, verify the endpoint path, reachability, and authentication header. > **PR commands fail** > > Confirm `gh` is installed and authenticated for the repository. Check the repo and base-branch options. CLI `--triage` additionally needs a configured model backend. ## Get help Open a [GitHub issue](https://github.com/Graphify-Labs/graphify/issues) or join [Discord](https://discord.gg/graphify). Include the installed version, operating system, exact command, and a sanitized error. A small reproducible example is more useful than a private repository dump. [Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/troubleshooting.mdx) [Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Ftroubleshooting) [PreviousInstallation](/installation) [NextNotes for agents](/for-agents)