Parse explicit code relationships
Local syntax analysis extracts connections such as imports and calls, giving an agent a structured starting point for a codebase question.
Graphify
Graphify maps code and supporting material into a queryable knowledge graph. Explore the local CLI and its agent Skill together, distinguish extracted links from inferred relationships, and use source-backed context for repository investigations.
Trace the impact of a change through a code graph
Identify a feature, refactor boundary, or design claim to investigate in the source. Prepare a Graphify-based reading plan that narrows relevant files and preserves relationship provenance, with final conclusions checked in code rather than accepted from inferred links alone.
Identify the repository, entry points, proposed change, and files to exclude.
Copy the request into a new Floatboat conversation and provide the required material.
Download FloatboatYour request for Floatboat
Preview and copy the request. It is not sent automatically from this page.
Reference: Graphify https://github.com/Graphify-Labs/graphify Read the original documentation and check the current environment and dependencies. Propose any new installation or tool connection before proceeding. My task: Refer to Graphify’s official installation and CLI documentation to analyze an authentication-module change. Check whether graphify is available, plan the graph build, and identify callers and affected modules. Validate graph findings in source; propose any setup before executing it. Expected deliverable: A dependency path and affected-module report with source checks and explicit graph gaps.
About Graphify
Graphify combines a Python command-line tool with agent integration instructions to build and query knowledge graphs. The open project is maintained by Graphify Labs. Its CLI and /graphify Skill describe one workflow, so this page covers them together rather than creating competing introductions.
Code parsing uses local AST analysis, while semantic processing of documents or media can use an assistant model or configured backend. Graph relationships distinguish extracted source connections from inferred ones. The generated graph, interactive view, and report are useful navigation artifacts, but an inferred edge is not independent proof that a behavior occurs.
For a Floatboat repository task, use the graph as a map to relevant source files and relationships before reviewing the actual code. Keep the graph current with the source revision. The Apache-2.0 local tool and hosted Graphify services have distinct setup, data-processing, and commercial conditions.
Turn Repository Structure into Navigable Context
Graphify distinguishes parsed code relationships, focused queries, and relationship provenance. Compare those layers when narrowing an investigation, then return to the cited files so semantic links and extracted structure do not silently become claims of verified program behavior.
Query a focused part of the graph
Query, path, and explain operations can select a relevant subgraph rather than supplying an entire repository as undifferentiated context.
Retain relationship provenance
Extracted and inferred labels help distinguish direct source evidence from relationships that still need validation.
Use Cases for Graphify
Feature investigation, refactor planning, and design-note comparison require different paths through a codebase. Use Graphify to narrow those paths, then confirm relationships in the cited files while preserving the distinction between inferred connections and verified behavior.
Locate the path behind a feature
Feature investigation can begin with an entry point, key concepts, and a bounded source scope. Follow the graph's connected modules and concepts, then open the relevant files to confirm the path before proposing edits. Distinguish inferred relationships from source-confirmed calls and implementation locations.
Check a refactor boundary
A structural refactor needs its callers, dependencies, public interfaces, and related tests considered together. Inspect connected documentation as well as code before drawing the boundary of the change. The impact report should identify which contracts and tests must remain intact when modules are reorganized.
Connect code to its design notes
Connecting design notes to code requires both sources in the same investigation. Map design claims to implementation locations, checking the files that establish actual behavior. Keep semantic graph inferences separate and mark evidence gaps so a plausible relationship is not reported as a verified implementation fact.
Check the provenance of a graph relation
A useful connection in the graph may come from explicit code structure or a semantic inference. Inspect the relation's recorded origin and the cited material before using it to support an implementation claim. Keep inferred links as investigation leads when direct evidence is missing, and document what would need to be checked rather than presenting the graph itself as proof of behavior.
Choose Graphify’s processing boundary
Local AST processing and model-backed semantic tasks can handle source material differently. Identify which files remain local and which may reach a model or hosted service before investigation begins, rather than treating every graph operation as the same data path.
Choose local or hosted processing
Confirm which files stay in local AST processing and which semantic tasks use a model or hosted backend.
Build and verify a Graphify graph
Graph-based investigation needs the relevant tool and agent instructions available before the graph guides a change. Check the setup, follow a focused query, and compare its claims with current source files so the analysis remains tied to the revision being investigated.
Install the tool and agent guidance
The documented local package is graphifyy. Agent registration supplies instructions; confirm that the CLI and chosen integration are available.
Refresh and verify the graph
Rebuild or update after relevant source changes, and check the actual code before accepting a graph-derived claim.
Related Software Projects
Compare the workflows, operating requirements, and source licenses of these projects.
Graphify FAQ
Is Graphify software or a Skill?
It includes both: a local tool builds and queries the graph, and agent instructions explain how to use it. They belong to one project overview.
Is the graph a vector database?
The documented core uses a traversable knowledge graph rather than an embedding-based vector store. Relationships and paths are explicit parts of the output.
Does all processing stay on the machine?
Local code parsing is deterministic AST analysis. Document and media interpretation can use a configured model backend; hosted services have their own data paths.
What do EXTRACTED and INFERRED mean?
They distinguish direct source extraction from relationships resolved or inferred by Graphify. An inferred relationship should be checked before it supports a consequential conclusion.
Can a saved graph become stale?
Yes. It represents the analyzed source state. Refresh it after relevant changes and preserve revision context when sharing findings.
Does the open-source license include Graphify Cloud?
Apache-2.0 applies to the published local project. Hosted services, accounts, and model usage have separate access and commercial terms.