<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Graphify Labs Inc</title>
    <description>The latest articles on DEV Community by Graphify Labs Inc (graphify).</description>
    <link>https://dev.to/graphify</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Forganization%2Fprofile_image%2F15091%2F831bf484-c707-431a-85cf-c12370867d8b.png</url>
      <title>DEV Community: Graphify Labs Inc</title>
      <link>https://dev.to/graphify</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/graphify"/>
    <language>en</language>
    <item>
      <title>7 Python libraries I'd pick to build AI agents in 2026</title>
      <dc:creator>Syed Fahad</dc:creator>
      <pubDate>Mon, 16 Nov 2026 17:26:23 +0000</pubDate>
      <link>https://dev.to/graphify/7-python-libraries-id-pick-to-build-ai-agents-in-2026-60e</link>
      <guid>https://dev.to/graphify/7-python-libraries-id-pick-to-build-ai-agents-in-2026-60e</guid>
      <description>&lt;p&gt;"Which agent framework should I use?" is the wrong first question. The better one is: which part of the agent are you building?&lt;/p&gt;

&lt;p&gt;An agent isn't one thing. It's a loop that calls a model, some tools, some state, and some context about the world it's working in. So instead of crowning one framework, here are seven Python libraries I'd actually pick in 2026, each for one job, with a short snippet for every one.&lt;/p&gt;

&lt;p&gt;I work on &lt;a href="https://github.com/Graphify-Labs/graphify" rel="noopener noreferrer"&gt;Graphify&lt;/a&gt; (it's #7). Everything else is here because it's genuinely good at its job.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;TL;DR&lt;/strong&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;#&lt;/th&gt;
&lt;th&gt;Library&lt;/th&gt;
&lt;th&gt;Pick it for&lt;/th&gt;
&lt;th&gt;⭐ (Nov 16, 2026)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;Pydantic AI&lt;/td&gt;
&lt;td&gt;Typed agents and validated output&lt;/td&gt;
&lt;td&gt;~21.2k&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;LangGraph&lt;/td&gt;
&lt;td&gt;Stateful, multi-step workflows&lt;/td&gt;
&lt;td&gt;~45k&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;OpenAI Agents SDK&lt;/td&gt;
&lt;td&gt;A small agent loop with tools and handoffs&lt;/td&gt;
&lt;td&gt;~30.7k&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;smolagents&lt;/td&gt;
&lt;td&gt;Agents that write and run Python&lt;/td&gt;
&lt;td&gt;~30.4k&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;MCP Python SDK&lt;/td&gt;
&lt;td&gt;Exposing tools to any MCP client&lt;/td&gt;
&lt;td&gt;~24.9k&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;td&gt;LiteLLM&lt;/td&gt;
&lt;td&gt;One API for every model provider&lt;/td&gt;
&lt;td&gt;~63.3k&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;Graphify&lt;/td&gt;
&lt;td&gt;Giving coding agents a map of a codebase&lt;/td&gt;
&lt;td&gt;~148k&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  1. Pydantic AI: when the output has to be right
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://github.com/pydantic/pydantic-ai" rel="noopener noreferrer"&gt;Pydantic AI&lt;/a&gt; (MIT) is from the Pydantic team, and it feels like it. You describe the output as a model, and the agent has to hand you back something that validates.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;pydantic&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;BaseModel&lt;/span&gt;
&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;pydantic_ai&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;Agent&lt;/span&gt;

&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Answer&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;BaseModel&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;city&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;
    &lt;span class="n"&gt;country&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;

&lt;span class="n"&gt;agent&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Agent&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"test"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;output_type&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nc"&gt;Answer&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;instructions&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"Answer briefly."&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;agent&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;run_sync&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"Where were the 2012 Olympics?"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;output&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Small trick: &lt;code&gt;"test"&lt;/code&gt; is a built-in fake model, so this runs offline and is great in unit tests. Swap in a real model string like &lt;code&gt;"openai:gpt-4o"&lt;/code&gt; when you're ready.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Pick it when&lt;/strong&gt; your agent feeds another system and a malformed response is a bug.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. LangGraph: when the agent is really a workflow
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://github.com/langchain-ai/langgraph" rel="noopener noreferrer"&gt;LangGraph&lt;/a&gt; (MIT) models your agent as a graph of steps with shared state. Branches, retries, human approval, checkpoints: it's built for the parts of an agent that need to be boring and reliable.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;typing&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;TypedDict&lt;/span&gt;
&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;langgraph&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;graph&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;StateGraph&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;START&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;END&lt;/span&gt;

&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;State&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;TypedDict&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;question&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;
    &lt;span class="n"&gt;answer&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;think&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;State&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;dict&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"answer"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"thinking about: {state['question']}"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="n"&gt;graph&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;StateGraph&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;State&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;graph&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;add_node&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"think"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;think&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;graph&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;add_edge&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="no"&gt;START&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"think"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;graph&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;add_edge&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"think"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;END&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;app&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;graph&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nb"&gt;compile&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;app&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;invoke&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"question"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"what calls make_context?"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Pick it when&lt;/strong&gt; you can draw your agent on a whiteboard as boxes and arrows.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. OpenAI Agents SDK: the smallest useful agent loop
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://github.com/openai/openai-agents-python" rel="noopener noreferrer"&gt;OpenAI Agents SDK&lt;/a&gt; (MIT) gives you agents, tools, handoffs between agents, guardrails and tracing, and not much else. A plain Python function becomes a tool with one decorator.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;agents&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;Agent&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Runner&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;function_tool&lt;/span&gt;

&lt;span class="nd"&gt;@function_tool&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;get_weather&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;city&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="s2"&gt;"""Get the weather for a city."""&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"It's sunny in {city}."&lt;/span&gt;

&lt;span class="n"&gt;agent&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Agent&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"Helper"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;instructions&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"Be concise."&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;tools&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;get_weather&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Runner&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;run_sync&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;agent&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"What's the weather in Hyderabad?"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;final_output&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Pick it when&lt;/strong&gt; you want a working agent in 15 lines and you'll add structure later.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. smolagents: agents that think in code
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://github.com/huggingface/smolagents" rel="noopener noreferrer"&gt;smolagents&lt;/a&gt; (Apache-2.0) from Hugging Face has a fun twist: its &lt;code&gt;CodeAgent&lt;/code&gt; writes Python to call your tools instead of emitting JSON tool calls. For multi-step tasks that's often a more natural fit, since the model can loop, branch and combine results in one go.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;smolagents&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;CodeAgent&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;InferenceClientModel&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;tool&lt;/span&gt;

&lt;span class="nd"&gt;@tool&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;word_count&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="s2"&gt;"""Count the words in a piece of text.

    Args:
        text: The text to count.
    """&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;agent&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;CodeAgent&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tools&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;word_count&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;model&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nc"&gt;InferenceClientModel&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;agent&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;run&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"How many words are in 'agents are just loops with tools'?"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Pick it when&lt;/strong&gt; your task looks more like a small script than a single tool call.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. MCP Python SDK: write a tool once, use it everywhere
&lt;/h2&gt;

&lt;p&gt;The official &lt;a href="https://github.com/modelcontextprotocol/python-sdk" rel="noopener noreferrer"&gt;MCP Python SDK&lt;/a&gt; (MIT) is how you expose your tools to Claude Code, Cursor, Codex and every other MCP client. Heads up if you're coming from older tutorials: in &lt;code&gt;mcp&lt;/code&gt; 2.x, &lt;code&gt;FastMCP&lt;/code&gt; is now &lt;code&gt;MCPServer&lt;/code&gt;.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;mcp&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;server&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;mcpserver&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;MCPServer&lt;/span&gt;

&lt;span class="n"&gt;server&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;MCPServer&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"demo"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="nd"&gt;@server&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;tool&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;add&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="s2"&gt;"""Add two numbers."""&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;

&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;__name__&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s2"&gt;"__main__"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;server&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;run&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Pick it when&lt;/strong&gt; more than one agent or client should use the same tools. And keep the tool list short. Every schema costs context on every turn.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. LiteLLM: stop rewriting provider code
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://github.com/BerriAI/litellm" rel="noopener noreferrer"&gt;LiteLLM&lt;/a&gt; gives you one &lt;code&gt;completion()&lt;/code&gt; call for OpenAI, Anthropic, Gemini, Bedrock, local models and a long list of others. Switching models becomes a string change. It also has a proxy server if you want keys, budgets and logging in one place.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;litellm&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;completion&lt;/span&gt;

&lt;span class="n"&gt;resp&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;completion&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;model&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"anthropic/claude-sonnet-4-5"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;messages&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"role"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"user"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"content"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"Say hi"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;mock_response&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"hi!"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;  &lt;span class="c1"&gt;# remove this to make a real call&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;resp&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;choices&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;message&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;content&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Pick it when&lt;/strong&gt; you want to compare models, or you don't want your agent married to one provider.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Graphify: give your coding agent a map
&lt;/h2&gt;

&lt;p&gt;If the agent you're building works on code, the hardest part is usually context: knowing what calls what, where things live, and what breaks if you touch something. &lt;a href="https://github.com/Graphify-Labs/graphify" rel="noopener noreferrer"&gt;Graphify&lt;/a&gt; (Apache-2.0) turns a repo into a knowledge graph with tree-sitter (no embeddings, no vector store) and serves it to agents over MCP.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pip install &lt;span class="s2"&gt;"graphifyy[mcp]"&lt;/span&gt;
graphify update .
claude mcp add --transport stdio graphify -- graphify-mcp &lt;span class="s2"&gt;"$(pwd)/graphify-out/graph.json"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;On &lt;a href="https://github.com/pallets/click" rel="noopener noreferrer"&gt;Click&lt;/a&gt; that build takes about 3 seconds and produces 3,498 nodes and 6,798 edges. Then "who calls &lt;code&gt;make_context&lt;/code&gt;?" is one &lt;code&gt;get_neighbors&lt;/code&gt; call that returns every caller and callee with file and line, in about 188 tokens. Reading the files that mention it would be close to 49,000.&lt;/p&gt;

&lt;p&gt;The PyPI package is &lt;code&gt;graphifyy&lt;/code&gt; (two y's); the command is &lt;code&gt;graphify&lt;/code&gt;. If you'd rather not run it locally, hosted &lt;a href="https://app.graphify.com" rel="noopener noreferrer"&gt;Graphify&lt;/a&gt; keeps the graph fresh for your GitHub repos.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Pick it when&lt;/strong&gt; your agent spends more time grepping than coding.&lt;/p&gt;

&lt;h2&gt;
  
  
  How I'd combine them
&lt;/h2&gt;

&lt;p&gt;You don't need all seven. A setup I like for a coding agent:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;LiteLLM&lt;/strong&gt; for the model call&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pydantic AI&lt;/strong&gt; or the &lt;strong&gt;OpenAI Agents SDK&lt;/strong&gt; for the loop&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;LangGraph&lt;/strong&gt; once you need state, retries or approvals&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;MCP&lt;/strong&gt; for tools, with &lt;strong&gt;Graphify&lt;/strong&gt; as the codebase map&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If this list helped, a ⭐ on &lt;a href="https://github.com/Graphify-Labs/graphify" rel="noopener noreferrer"&gt;Graphify's GitHub&lt;/a&gt; genuinely helps, and come say hi in &lt;a href="https://discord.gg/graphify" rel="noopener noreferrer"&gt;our Discord&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What's the one Python library you'd add to this list for building agents? Tell me in the comments and why. I'll try the best ones and do a follow-up.&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>python</category>
      <category>ai</category>
      <category>agents</category>
      <category>opensource</category>
    </item>
    <item>
      <title>Your coding agent doesn't need more MCP tools. It needs a map.</title>
      <dc:creator>Syed Fahad</dc:creator>
      <pubDate>Mon, 16 Nov 2026 16:57:55 +0000</pubDate>
      <link>https://dev.to/graphify/your-coding-agent-doesnt-need-more-mcp-tools-it-needs-a-map-28lh</link>
      <guid>https://dev.to/graphify/your-coding-agent-doesnt-need-more-mcp-tools-it-needs-a-map-28lh</guid>
      <description>&lt;p&gt;The MCP conversation on DEV this month has been great. &lt;a href="https://dev.to/sylwia-lask/mcp-is-dead-simple-and-thats-exactly-the-problem-5811"&gt;"MCP Is Dead Simple. And That's Exactly the Problem"&lt;/a&gt; and &lt;a href="https://dev.to/aws-builders/mcp-token-cost-i-cut-my-mcp-server-from-15-tools-to-4-cek"&gt;"MCP Token Cost: I Cut My MCP Server From 15 Tools to 4"&lt;/a&gt; both land on the same point: MCP is easy to add, and that's exactly how your context window disappears.&lt;/p&gt;

&lt;p&gt;I agree. And I think there's a second half to it that we don't talk about enough.&lt;/p&gt;

&lt;p&gt;Even with a lean tool list, a coding agent still burns most of its context on one thing: finding its way around your code. Grep, open a file, grep again, open three more. More tools don't fix that. A map does.&lt;/p&gt;

&lt;p&gt;I work on &lt;a href="https://github.com/Graphify-Labs/graphify" rel="noopener noreferrer"&gt;Graphify&lt;/a&gt;, so I have a horse in this race. But the numbers below are from my own terminal, and you can rerun every one of them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Two places your tokens go
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;1. Tool definitions.&lt;/strong&gt; Every tool schema sits in context on every turn, whether the agent uses it or not. The 15-tools-to-4 post cites GitHub's official MCP server at about 55,000 tokens across 93 tool definitions before you ask a single question. Stack five or six servers like that and you've spent a big slice of the window on menus.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Navigation.&lt;/strong&gt; This one is sneakier. The agent asks "who calls this function?" and the only way it knows to answer is to search text and read files. Files are big. The answer is small.&lt;/p&gt;

&lt;p&gt;Most of the advice so far targets the first problem: fewer, sharper tools. That's right. Here's what happens when you also go after the second one.&lt;/p&gt;

&lt;h2&gt;
  
  
  The experiment: one question, two ways
&lt;/h2&gt;

&lt;p&gt;Repo: &lt;a href="https://github.com/pallets/click" rel="noopener noreferrer"&gt;Click&lt;/a&gt;, the Python CLI library, at commit &lt;code&gt;8abb77a&lt;/code&gt;. Question: &lt;strong&gt;"What calls &lt;code&gt;make_context&lt;/code&gt;, and what does it call?"&lt;/strong&gt; Token counts use OpenAI's &lt;code&gt;o200k_base&lt;/code&gt; tokenizer via &lt;code&gt;tiktoken&lt;/code&gt;.&lt;/p&gt;

&lt;h3&gt;
  
  
  Way 1: grep and read
&lt;/h3&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;grep -rn make_context --include=&lt;span class="s1"&gt;'*.py'&lt;/span&gt; --include=&lt;span class="s1"&gt;'*.md'&lt;/span&gt; .
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;12 matches across 5 files. The grep output itself is tiny, about &lt;strong&gt;257 tokens&lt;/strong&gt;. But matches aren't answers. Grep tells you where the string appears, not who calls whom. So the agent opens the files to figure it out.&lt;/p&gt;

&lt;p&gt;Those 5 files add up to about &lt;strong&gt;48,900 tokens&lt;/strong&gt;. &lt;code&gt;src/click/core.py&lt;/code&gt; alone is about &lt;strong&gt;33,600&lt;/strong&gt;.&lt;/p&gt;

&lt;h3&gt;
  
  
  Way 2: ask the graph
&lt;/h3&gt;

&lt;p&gt;I built a graph of the same repo once (&lt;code&gt;graphify update .&lt;/code&gt;, about 3 seconds, no LLM, no embeddings) and served it over MCP with &lt;code&gt;graphify-mcp&lt;/code&gt;. Then one tool call:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"tool"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"get_neighbors"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nl"&gt;"arguments"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"label"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"make_context"&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Neighbors of .make_context():
  --&amp;gt; .parse_args() [calls] [EXTRACTED] at=src/click/core.py:L1389
  --&amp;gt; Any [references] [EXTRACTED] at=src/click/core.py:L1355
  --&amp;gt; Context [references] [EXTRACTED] at=src/click/core.py:L1355
  &amp;lt;-- .main() [calls] [EXTRACTED] at=src/click/core.py:L1584
  &amp;lt;-- Command [method] [EXTRACTED] at=src/click/core.py:L1355
  &amp;lt;-- This function when given an info name and arguments will kick off the parsing… [rationale_for] [EXTRACTED] at=src/click/core.py:L1362
  &amp;lt;-- _resolve_context() [calls] [INFERRED 0.85] at=src/click/shell_completion.py:L706
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That's about &lt;strong&gt;188 tokens&lt;/strong&gt;. Callers, callees, file and line for each, and a tag on every edge: &lt;code&gt;EXTRACTED&lt;/code&gt; means read straight from the source, &lt;code&gt;INFERRED&lt;/code&gt; means resolved by Graphify with a confidence score.&lt;/p&gt;

&lt;p&gt;It even caught the cross-file caller, &lt;code&gt;_resolve_context()&lt;/code&gt; in &lt;code&gt;shell_completion.py&lt;/code&gt;. That's the one you'd miss if you only opened &lt;code&gt;core.py&lt;/code&gt;.&lt;/p&gt;

&lt;h3&gt;
  
  
  The scoreboard
&lt;/h3&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;Grep + read&lt;/th&gt;
&lt;th&gt;Code graph over MCP&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Calls to answer&lt;/td&gt;
&lt;td&gt;1 search + up to 5 file reads&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tokens in context&lt;/td&gt;
&lt;td&gt;~257 search + ~48,900 files&lt;/td&gt;
&lt;td&gt;~188&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Says who calls whom&lt;/td&gt;
&lt;td&gt;You work it out&lt;/td&gt;
&lt;td&gt;Yes, with direction&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;File and line per hop&lt;/td&gt;
&lt;td&gt;From grep only&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;And the tool menu that makes this possible? &lt;code&gt;graphify-mcp&lt;/code&gt; exposes &lt;strong&gt;10 tools&lt;/strong&gt;. I dumped their names, descriptions and input schemas from the server: about &lt;strong&gt;1,600 tokens&lt;/strong&gt; total.&lt;/p&gt;

&lt;h2&gt;
  
  
  So what does "a map" actually mean?
&lt;/h2&gt;

&lt;p&gt;Not a bigger prompt. Not a CLAUDE.md that goes stale. A structure the agent can query:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Nodes&lt;/strong&gt; for functions, classes, modules and docs&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Edges&lt;/strong&gt; for calls, imports, references and inheritance&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Communities&lt;/strong&gt; that roughly match your subsystems (Click has 213)&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Freshness&lt;/strong&gt; baked in. &lt;code&gt;graph_stats&lt;/code&gt; on Click ends with &lt;code&gt;Built at commit: 8abb77a… (matches HEAD)&lt;/code&gt;, so the agent knows the map matches the code.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Once that exists, a lot of questions collapse into one call:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;"Who calls this?" → &lt;code&gt;get_neighbors&lt;/code&gt;
&lt;/li&gt;
&lt;li&gt;"How does A reach B?" → &lt;code&gt;shortest_path&lt;/code&gt;
&lt;/li&gt;
&lt;li&gt;"What's the core of this repo?" → &lt;code&gt;god_nodes&lt;/code&gt;
&lt;/li&gt;
&lt;li&gt;"Give me just enough context for this question" → &lt;code&gt;query_graph&lt;/code&gt;, which stays inside a token budget (2,000 by default)&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That's the same lesson as the lean-tools posts, applied to the codebase instead of the API: give the model fewer, better-shaped things to look at.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it on your repo (5 minutes)
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pip install &lt;span class="s2"&gt;"graphifyy[mcp]"&lt;/span&gt;
&lt;span class="nb"&gt;cd&lt;/span&gt; your-repo &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; graphify update .
claude mcp add --transport stdio graphify -- graphify-mcp &lt;span class="s2"&gt;"$(pwd)/graphify-out/graph.json"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Cursor and other JSON clients work too. The &lt;a href="https://docs.graphify.com/open-source/mcp-server" rel="noopener noreferrer"&gt;MCP server docs&lt;/a&gt; have every config. If you'd rather not run anything locally, hosted &lt;a href="https://app.graphify.com" rel="noopener noreferrer"&gt;Graphify&lt;/a&gt; indexes your GitHub repos and keeps the graph fresh, and it connects to Claude Code with one command.&lt;/p&gt;

&lt;p&gt;If this was useful, a ⭐ on &lt;a href="https://github.com/Graphify-Labs/graphify" rel="noopener noreferrer"&gt;GitHub&lt;/a&gt; genuinely helps.&lt;/p&gt;

&lt;h2&gt;
  
  
  Your turn
&lt;/h2&gt;

&lt;p&gt;I'm curious where everyone's tokens actually go.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;When you look at a long agent session, what eats more of your context: tool definitions, or the agent reading files to find its way around?&lt;/strong&gt; Drop your numbers or your gut feel in the comments. I'll rerun this experiment on any public repo you name.&lt;/p&gt;

</description>
      <category>mcp</category>
      <category>ai</category>
      <category>agents</category>
      <category>discuss</category>
    </item>
    <item>
      <title>I turned Click into a 3,498-node code graph and plugged it into Claude Code over MCP. Here's the setup.</title>
      <dc:creator>Syed Fahad</dc:creator>
      <pubDate>Wed, 11 Nov 2026 13:06:24 +0000</pubDate>
      <link>https://dev.to/graphify/i-turned-click-into-a-3498-node-code-graph-and-plugged-it-into-claude-code-over-mcp-heres-the-4kkc</link>
      <guid>https://dev.to/graphify/i-turned-click-into-a-3498-node-code-graph-and-plugged-it-into-claude-code-over-mcp-heres-the-4kkc</guid>
      <description>&lt;p&gt;Every time I ask Claude Code "who calls this?", I watch it grep, open a file, grep again, and open three more. It gets there. It just takes the long way round.&lt;/p&gt;

&lt;p&gt;So this week I gave it a map instead. I took &lt;a href="https://github.com/pallets/click" rel="noopener noreferrer"&gt;Click&lt;/a&gt;, the Python CLI library (~17.8k ⭐), built a knowledge graph of it in about 3 seconds, and served that graph to Claude Code as MCP tools. Below is every command, plus the real output, so you can do the same on your own repo in ten minutes.&lt;/p&gt;

&lt;p&gt;I work on &lt;a href="https://github.com/Graphify-Labs/graphify" rel="noopener noreferrer"&gt;Graphify&lt;/a&gt;, the tool I'm using here. If this ends up useful, a ⭐ on GitHub helps a lot.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;TL;DR:&lt;/strong&gt; &lt;code&gt;pip install "graphifyy[mcp]"&lt;/code&gt;, run &lt;code&gt;graphify update .&lt;/code&gt; in your repo, then &lt;code&gt;claude mcp add&lt;/code&gt; the &lt;code&gt;graphify-mcp&lt;/code&gt; server. Claude Code gets 10 graph tools for nodes, neighbours, paths and PR impact.&lt;/p&gt;

&lt;h2&gt;
  
  
  What you need
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Python 3.10+ and a repo you know well (I used Click at commit &lt;code&gt;8abb77a&lt;/code&gt;, so the numbers below are reproducible)&lt;/li&gt;
&lt;li&gt;Claude Code installed (&lt;code&gt;claude&lt;/code&gt; on your PATH)&lt;/li&gt;
&lt;li&gt;About ten minutes&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Step 1: install the CLI and the MCP extra
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pip install &lt;span class="s2"&gt;"graphifyy[mcp]"&lt;/span&gt;
graphify --version
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;graphify 0.9.104
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The package on PyPI is &lt;code&gt;graphifyy&lt;/code&gt; (two y's). The command is &lt;code&gt;graphify&lt;/code&gt;. The &lt;code&gt;[mcp]&lt;/code&gt; extra adds the &lt;code&gt;graphify-mcp&lt;/code&gt; server.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 2: build the graph
&lt;/h2&gt;

&lt;p&gt;From the repo root:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git clone https://github.com/pallets/click &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="nb"&gt;cd&lt;/span&gt; click
graphify update .
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Re-extracting code files in . (no LLM needed)...
[graphify watch] Rebuilt: 3498 nodes, 6798 edges, 213 communities
[graphify watch] graph.json, graph.html and GRAPH_REPORT.md updated in graphify-out
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That took 3.3 seconds of wall-clock time on my box for 156 files. No API key, no embeddings, no vector database. It parses the code with tree-sitter and writes three files into &lt;code&gt;graphify-out/&lt;/code&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;graph.json&lt;/code&gt;, the graph itself, which the MCP server reads&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;graph.html&lt;/code&gt;, an interactive view you can open in a browser&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;GRAPH_REPORT.md&lt;/code&gt;, a summary with the most connected nodes and the communities (think subsystems)&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Before wiring anything up, I like to sanity-check that the graph "gets" the codebase. The most connected nodes in Click are exactly what you'd guess if you've used it:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;graphify god-nodes --top 5
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;God nodes (most connected):
  1. Context - 185 edges
  2. Command - 110 edges
  3. Parameter - 98 edges
  4. CliRunner - 82 edges
  5. Option - 66 edges
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;Context&lt;/code&gt; sitting at the top with 185 edges is the right answer. Almost everything in Click touches it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 3: register the server with Claude Code
&lt;/h2&gt;

&lt;p&gt;Run this in a normal terminal, not inside a Claude Code session, and use an absolute path to &lt;code&gt;graph.json&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;claude mcp add --transport stdio graphify -- graphify-mcp /absolute/path/to/click/graphify-out/graph.json
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Start a new Claude Code session and run &lt;code&gt;/mcp&lt;/code&gt;. You should see &lt;code&gt;graphify&lt;/code&gt; listed.&lt;/p&gt;

&lt;p&gt;If you use Cursor or another JSON-config client, the same server goes in &lt;code&gt;mcpServers&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"mcpServers"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nl"&gt;"graphify"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="nl"&gt;"command"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"graphify-mcp"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="nl"&gt;"args"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"/absolute/path/to/click/graphify-out/graph.json"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Step 4: see what Claude Code actually gets back
&lt;/h2&gt;

&lt;p&gt;The server exposes 10 tools. I listed them straight from the server with an MCP client:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;query_graph, get_node, get_neighbors, get_community, god_nodes,
graph_stats, shortest_path, list_prs, get_pr_impact, triage_prs
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Here's what three of them return on Click. This is the exact text Claude Code receives, so it's worth seeing once.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;code&gt;graph_stats&lt;/code&gt;&lt;/strong&gt; tells the agent how big the graph is and whether it's fresh:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Nodes: 3498
Edges: 6798
Communities: 213
EXTRACTED: 77%
INFERRED: 23%
AMBIGUOUS: 0%
Built at commit: 8abb77a8432e03ed14a95f972b44f905279415a7 (matches HEAD)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That last line is my favourite. The agent can tell whether the graph matches the code it's looking at.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;code&gt;get_neighbors&lt;/code&gt;&lt;/strong&gt; answers "what does this touch, and what touches it?" in one call. Here it is for &lt;code&gt;_resolve_context()&lt;/code&gt; in shell completion:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Neighbors of _resolve_context():
  --&amp;gt; .make_context() [calls] [INFERRED 0.85] at=src/click/shell_completion.py:L706
  --&amp;gt; Command [uses] [INFERRED 0.95] at=src/click/shell_completion.py:L692
  --&amp;gt; Context [uses] [INFERRED 0.95] at=src/click/shell_completion.py:L696
  --&amp;gt; Group [uses] [INFERRED 0.95] at=src/click/shell_completion.py:L712
  &amp;lt;-- .get_completions() [calls] [EXTRACTED] at=src/click/shell_completion.py:L363
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Every edge has a direction, a relation, a file and line, and a tag. &lt;code&gt;EXTRACTED&lt;/code&gt; means it was read straight from the source. &lt;code&gt;INFERRED&lt;/code&gt; means Graphify resolved it, with a confidence score. So the agent knows which hops it can trust as-is.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;code&gt;shortest_path&lt;/code&gt;&lt;/strong&gt; answers "how does A reach B?":&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Shortest path (1 hops):
  echo() --calls [EXTRACTED]--&amp;gt; resolve_color_default()
Path confidence: EXTRACTED (weakest hop 1: calls)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Step 5: prompts I'd try first
&lt;/h2&gt;

&lt;p&gt;Once it's connected, ask questions that are about structure, not about one file:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;"Use the graphify tools: what calls &lt;code&gt;_resolve_context()&lt;/code&gt; and what does it depend on?"&lt;/li&gt;
&lt;li&gt;"Find the shortest path from &lt;code&gt;echo()&lt;/code&gt; to &lt;code&gt;resolve_color_default()&lt;/code&gt; and explain each hop."&lt;/li&gt;
&lt;li&gt;"Which community does &lt;code&gt;CliRunner&lt;/code&gt; belong to, and what else is in it?"&lt;/li&gt;
&lt;li&gt;"What are the 10 most connected nodes in this repo? Give me a one-line tour of each."&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Saying "use the graphify tools" in the first prompt or two makes it obvious which tools you want. The rest is just asking the questions you'd normally answer with five greps.&lt;/p&gt;

&lt;h2&gt;
  
  
  Two small things that make it nicer
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Names that collide get flagged, not guessed.&lt;/strong&gt; Click has three different &lt;code&gt;echo()&lt;/code&gt; functions. Ask for one by bare name and Graphify tells you so (node IDs trimmed):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Ambiguous: 'echo()' matches 3 nodes in different files.
  src/click/testing.py
  src/click/utils.py
  tests/test_utils/test_prompt.py
Retry with path::symbol using one of the paths above
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;For an agent, one extra call beats confidently walking down the wrong function.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Big answers stay inside a budget.&lt;/strong&gt; &lt;code&gt;query_graph&lt;/code&gt; caps its output (2,000 tokens by default) and says when it trimmed something, so the agent knows to narrow the question instead of assuming it saw everything.&lt;/p&gt;

&lt;h2&gt;
  
  
  Keeping the graph fresh
&lt;/h2&gt;

&lt;p&gt;After you change code, rerun:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;graphify update .
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It only re-extracts code, so it's quick. &lt;code&gt;graphify watch .&lt;/code&gt; rebuilds on every change if you'd rather not think about it.&lt;/p&gt;

&lt;p&gt;If you don't want to run any of this locally, hosted &lt;a href="https://app.graphify.com" rel="noopener noreferrer"&gt;Graphify&lt;/a&gt; indexes your GitHub repos and keeps the graph fresh for you. Claude Code connects to it with one command:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;claude mcp add --transport http --scope user graphify https://api.graphify.com/mcp
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then sign in from &lt;code&gt;/mcp&lt;/code&gt;. There's no API key to paste.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it on your repo
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;&lt;code&gt;pip install "graphifyy[mcp]"&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;graphify update .&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;claude mcp add --transport stdio graphify -- graphify-mcp $(pwd)/graphify-out/graph.json&lt;/code&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The &lt;a href="https://docs.graphify.com/open-source/mcp-server.md" rel="noopener noreferrer"&gt;MCP server docs&lt;/a&gt; cover HTTP mode for teams and every flag. If it helps, a ⭐ on &lt;a href="https://github.com/Graphify-Labs/graphify" rel="noopener noreferrer"&gt;GitHub&lt;/a&gt; means a lot, and I hang out in &lt;a href="https://discord.gg/graphify" rel="noopener noreferrer"&gt;our Discord&lt;/a&gt; if you get stuck.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What's the first question you'd ask an agent that can see your whole codebase as a graph? Drop it in the comments and I'll run it on Click.&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>claudecode</category>
      <category>mcp</category>
      <category>tutorial</category>
      <category>ai</category>
    </item>
    <item>
      <title>9 open-source tools that give AI coding agents real context</title>
      <dc:creator>Syed Fahad</dc:creator>
      <pubDate>Tue, 10 Nov 2026 13:11:55 +0000</pubDate>
      <link>https://dev.to/graphify/9-open-source-tools-that-give-ai-coding-agents-real-context-2bj</link>
      <guid>https://dev.to/graphify/9-open-source-tools-that-give-ai-coding-agents-real-context-2bj</guid>
      <description>&lt;p&gt;My coding agent is great at writing code and pretty bad at knowing where it is. Ask it to change one function and it greps, opens six files, guesses, and sometimes edits the wrong thing.&lt;/p&gt;

&lt;p&gt;So I went through the open-source tools people use to fix that. Here are the nine I'd actually point a friend to, what each one is good at, and how to try it in a couple of minutes.&lt;/p&gt;

&lt;p&gt;Quick disclosure: I work on Graphify, which is #1 here. Every tool on the list earns its spot. (If Graphify ends up useful to you, a ⭐ on &lt;a href="https://github.com/Graphify-Labs/graphify" rel="noopener noreferrer"&gt;GitHub&lt;/a&gt; genuinely helps.)&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;TL;DR:&lt;/strong&gt; "context" means three different things for an agent: the structure of &lt;em&gt;your&lt;/em&gt; code, the docs of &lt;em&gt;other people's&lt;/em&gt; libraries, and plain fast search. Pick one tool per job instead of one tool for everything.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Star counts were checked on GitHub on Nov 9, 2026.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Your own codebase: structure and relationships
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1. Graphify: a knowledge graph of your repo
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/Graphify-Labs/graphify" rel="noopener noreferrer"&gt;Graphify&lt;/a&gt; (Apache-2.0, ~145k ⭐) turns a codebase, plus its docs, SQL schemas, configs and PDFs, into a queryable knowledge graph. Parsing is local and deterministic (AST, no embeddings, no vector store), and every edge is tagged &lt;code&gt;EXTRACTED&lt;/code&gt; (read straight from the source) or &lt;code&gt;INFERRED&lt;/code&gt; (resolved by Graphify), so you can see why two things are connected.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pip install graphifyy
graphify path &lt;span class="s2"&gt;"FastAPI"&lt;/span&gt; &lt;span class="s2"&gt;"ModelField"&lt;/span&gt;
graphify explain &lt;span class="s2"&gt;"APIRouter"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;You get a &lt;code&gt;graph.json&lt;/code&gt;, an interactive &lt;code&gt;graph.html&lt;/code&gt;, and a &lt;code&gt;GRAPH_REPORT.md&lt;/code&gt; with the most-connected "god nodes" and Leiden communities (your subsystems). It runs as a &lt;code&gt;/graphify&lt;/code&gt; skill in Claude Code, Cursor, Codex and Gemini CLI, and there's an MCP server via &lt;code&gt;graphifyy[mcp]&lt;/code&gt;. If you'd rather not run anything locally, the hosted version is at &lt;a href="https://app.graphify.com" rel="noopener noreferrer"&gt;app.graphify.com&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Use it when&lt;/strong&gt; the question is "how does X connect to Y?" or "what breaks if I touch this?"&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Serena: IDE-grade symbol tools over MCP
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/oraios/serena" rel="noopener noreferrer"&gt;Serena&lt;/a&gt; (~31k ⭐) gives your agent the things your IDE already knows: find symbol, file outline, find references. It does this by driving real language servers (LSP), and the README lists support for over 40 languages. Licensing is per component: the SolidLSP client is MIT and the Serena app is GPL-3.0-or-later.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Use it when&lt;/strong&gt; you want symbol-level navigation and edits instead of text search.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Aider's repo map: the idea worth stealing
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/Aider-AI/aider" rel="noopener noreferrer"&gt;Aider&lt;/a&gt; (Apache-2.0, ~50k ⭐) is a terminal pair programmer, but the part I keep coming back to is its &lt;a href="https://aider.chat/docs/repomap.html" rel="noopener noreferrer"&gt;repo map&lt;/a&gt;. It builds a graph where files are nodes and dependencies are edges, ranks it, and sends the model only the most-referenced symbols that fit a token budget (&lt;code&gt;--map-tokens&lt;/code&gt;, 1k by default).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Use it when&lt;/strong&gt; you live in the terminal, or just read the doc. It's one of the clearest explanations of why structure beats dumping files.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Repomix: pack the whole repo into one file
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/yamadashy/repomix" rel="noopener noreferrer"&gt;Repomix&lt;/a&gt; (MIT, ~29k ⭐) packs a repository into a single AI-friendly file. The &lt;code&gt;--compress&lt;/code&gt; flag uses Tree-sitter to keep signatures and drop implementation details, and &lt;code&gt;--mcp&lt;/code&gt; runs it as an MCP server.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx repomix@latest --compress
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Use it when&lt;/strong&gt; you're pasting a small or medium repo into a chat model, or handing a snapshot to someone else's agent.&lt;/p&gt;

&lt;h2&gt;
  
  
  Search: finding the right lines fast
&lt;/h2&gt;

&lt;h3&gt;
  
  
  5. ast-grep (+ its MCP server): search by syntax, not text
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/ast-grep/ast-grep" rel="noopener noreferrer"&gt;ast-grep&lt;/a&gt; (MIT, ~16.5k ⭐) is a Rust CLI for structural search, lint and rewrite. You write patterns that look like code, and it matches syntax trees instead of strings. The official &lt;a href="https://github.com/ast-grep/ast-grep-mcp" rel="noopener noreferrer"&gt;ast-grep-mcp&lt;/a&gt; server exposes it to agents:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;uvx --from git+https://github.com/ast-grep/ast-grep-mcp ast-grep-server
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Use it when&lt;/strong&gt; "find every call to X with two arguments" is the real question.&lt;/p&gt;

&lt;h3&gt;
  
  
  6. Probe: AST-aware search with zero indexing
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/probelabs/probe" rel="noopener noreferrer"&gt;Probe&lt;/a&gt; (Apache-2.0, ~740 ⭐) is the smallest project on this list and punches well above its size. It combines ripgrep speed with Tree-sitter parsing, takes Elasticsearch-style boolean queries ranked with BM25, and returns whole functions instead of random line fragments. No embedding model, no index step.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"mcpServers"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"probe"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"command"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"npx"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nl"&gt;"args"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"-y"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"@probelabs/probe@latest"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"agent"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"--mcp"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Use it when&lt;/strong&gt; you want better-than-grep results without running a database.&lt;/p&gt;

&lt;h3&gt;
  
  
  7. Claude Context: semantic search over your code
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/zilliztech/claude-context" rel="noopener noreferrer"&gt;Claude Context&lt;/a&gt; (MIT, ~13k ⭐) from Zilliz is an MCP server that indexes your codebase into a vector database (Milvus or Zilliz Cloud) so the agent can search by meaning. It's the most "classic RAG" pick here, and it needs a vector DB and an embedding provider to run.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Use it when&lt;/strong&gt; your questions are fuzzy ("where do we handle retries?") and you're fine running a vector store.&lt;/p&gt;

&lt;h2&gt;
  
  
  Other people's code: docs and libraries
&lt;/h2&gt;

&lt;h3&gt;
  
  
  8. Context7: up-to-date library docs
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/upstash/context7" rel="noopener noreferrer"&gt;Context7&lt;/a&gt; (MIT, ~64k ⭐) from Upstash fixes the "the model learned an old version of this API" problem. Its MCP tools (&lt;code&gt;resolve-library-id&lt;/code&gt;, &lt;code&gt;query-docs&lt;/code&gt;) pull current, version-specific docs into the prompt. Setup is one command:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx ctx7 setup
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then add "use context7" to a prompt, or tell your agent to always use it for library questions.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Use it when&lt;/strong&gt; the bug is the agent using a deprecated API.&lt;/p&gt;

&lt;h3&gt;
  
  
  9. GitMCP: any GitHub repo as an MCP server
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/idosal/git-mcp" rel="noopener noreferrer"&gt;GitMCP&lt;/a&gt; (Apache-2.0, ~8.5k ⭐) is a free, remote MCP server. Point your agent at &lt;code&gt;https://gitmcp.io/{owner}/{repo}&lt;/code&gt; and it can read that project's docs and code, even if the model has never seen it. There's also a generic &lt;code&gt;gitmcp.io/docs&lt;/code&gt; endpoint for switching between repos.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Use it when&lt;/strong&gt; you're working against a niche library with no docs in the model's training data.&lt;/p&gt;

&lt;h2&gt;
  
  
  How I'd combine them
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;One structure tool&lt;/strong&gt; for your own repo: Graphify for relationships across code and docs, or Serena for symbol-level navigation.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One search tool&lt;/strong&gt;: ast-grep for exact syntax, Probe for ranked results, Claude Context if you want semantic search.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One docs tool&lt;/strong&gt;: Context7 for popular libraries, GitMCP for everything else.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Repomix and Aider's repo map are worth knowing either way, if only to understand what "giving the agent context" actually means.&lt;/p&gt;

&lt;p&gt;If you try Graphify, the fastest path is &lt;a href="https://app.graphify.com" rel="noopener noreferrer"&gt;app.graphify.com&lt;/a&gt;, or &lt;code&gt;pip install graphifyy&lt;/code&gt; and run &lt;code&gt;graphify&lt;/code&gt; on a repo you know well. A ⭐ on &lt;a href="https://github.com/Graphify-Labs/graphify" rel="noopener noreferrer"&gt;GitHub&lt;/a&gt; helps a lot, and I'd love to hear what it finds in your repo in &lt;a href="https://discord.gg/graphify" rel="noopener noreferrer"&gt;our Discord&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What's in your agent's context stack right now? Anything I missed that should be on this list?&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>claudecode</category>
      <category>devtools</category>
    </item>
    <item>
      <title>I mapped a 1,095-file repo into a knowledge graph in 5 minutes. Here's what it found.</title>
      <dc:creator>Syed Fahad</dc:creator>
      <pubDate>Wed, 04 Nov 2026 13:28:55 +0000</pubDate>
      <link>https://dev.to/graphify/i-mapped-a-1095-file-repo-into-a-knowledge-graph-in-5-minutes-heres-what-it-found-5d0b</link>
      <guid>https://dev.to/graphify/i-mapped-a-1095-file-repo-into-a-knowledge-graph-in-5-minutes-heres-what-it-found-5d0b</guid>
      <description>&lt;p&gt;Last week I pointed an AI agent at our own repo and asked it one thing: draw me a map. Five minutes and twenty-five seconds later I had 4,022 nodes, 10,079 edges and a picture of our codebase I'd never seen before, even though I work on it every day.&lt;/p&gt;

&lt;p&gt;Here's the full run, what came out, and how you can do the same on your repo.&lt;/p&gt;

&lt;h2&gt;
  
  
  The setup
&lt;/h2&gt;

&lt;p&gt;The repo is &lt;a href="https://github.com/Graphify-Labs/graphify" rel="noopener noreferrer"&gt;Graphify-Labs/graphify&lt;/a&gt;, at commit &lt;code&gt;dac0634&lt;/code&gt;. It has 1,095 files: Python source, tests, docs, examples and fixtures.&lt;/p&gt;

&lt;p&gt;I ran it inside Perplexity Computer with the Graphify skill enabled. I typed &lt;code&gt;/graphify&lt;/code&gt;, pasted the GitHub URL, and asked for a knowledge graph of the codebase. I didn't use a connector or upload anything. The agent cloned the public repo itself.&lt;/p&gt;

&lt;p&gt;If you'd rather run it locally:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pip &lt;span class="nb"&gt;install &lt;/span&gt;graphifyy
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then point it at any folder and let your coding agent (Claude Code, Cursor, Codex, whatever you use) query the graph.&lt;/p&gt;

&lt;h2&gt;
  
  
  What happened in 5m 25s
&lt;/h2&gt;

&lt;p&gt;The agent picked the 105 files that carry the code's structure out of the 1,095 and parsed them into a graph:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Metric&lt;/th&gt;
&lt;th&gt;Value&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Files mapped&lt;/td&gt;
&lt;td&gt;105 of 1,095&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Nodes&lt;/td&gt;
&lt;td&gt;4,022&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Directed edges&lt;/td&gt;
&lt;td&gt;10,079&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Communities&lt;/td&gt;
&lt;td&gt;192&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Wall-clock time&lt;/td&gt;
&lt;td&gt;5m 25s&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Every function, class and module becomes a node. Every call, import and containment becomes an edge. Then community detection groups everything into 192 clusters that roughly match how the code is organised.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flpzzqf95b6q0bo9p6oul.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flpzzqf95b6q0bo9p6oul.webp" alt="Interactive graph map of the Graphify repo" width="799" height="456"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What the graph told me
&lt;/h2&gt;

&lt;p&gt;This is where I stopped skimming and started reading.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;code&gt;_read_text()&lt;/code&gt; is the most connected function in the repo, with 270 links.&lt;/strong&gt; It's a tiny helper, and almost every extractor goes through it. If you're new to the codebase, this is the function to read first.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;code&gt;_make_id()&lt;/code&gt; comes second with 234 links.&lt;/strong&gt; Every node in every graph gets its identity here. Changing it changes everything downstream, and the graph shows that before you touch it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;code&gt;dispatch_command()&lt;/code&gt; calls 127 different functions.&lt;/strong&gt; That's the CLI's front door. One node shows the entire surface area of the tool.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;code&gt;extract.py&lt;/code&gt; has a degree of 442.&lt;/strong&gt; It's the gravitational centre of the project, which matches my gut feeling but now I have a number for it.&lt;/p&gt;

&lt;p&gt;The graph also caught a stale line in our docs. &lt;code&gt;ARCHITECTURE.md&lt;/code&gt; said &lt;code&gt;to_html&lt;/code&gt; lives in &lt;code&gt;export.py&lt;/code&gt;. The graph showed it's in &lt;code&gt;exporters/html.py&lt;/code&gt;. One query, one fixed doc.&lt;/p&gt;

&lt;h2&gt;
  
  
  What you get at the end
&lt;/h2&gt;

&lt;p&gt;The run produced three things:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;An interactive map you can pan, zoom and click through.&lt;/li&gt;
&lt;li&gt;A ZIP with &lt;code&gt;graph.json&lt;/code&gt;, &lt;code&gt;graph.html&lt;/code&gt; and notes, ready to drop into your agent's context.&lt;/li&gt;
&lt;li&gt;A written report of the hubs, communities and entry points.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Felunr34ly1mr7zd83bg9.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Felunr34ly1mr7zd83bg9.webp" alt="The three artifacts from the run" width="800" height="192"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;code&gt;graph.json&lt;/code&gt; is what matters for daily work. Instead of grepping and re-reading files every session, your agent asks the graph "what calls &lt;code&gt;_make_id&lt;/code&gt;?" and gets the answer from structure, not similarity.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it on your repo
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;&lt;code&gt;pip install graphifyy&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Run it on your project folder.&lt;/li&gt;
&lt;li&gt;Ask your agent: "What are the five most connected functions, and what depends on them?"&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;I'd love to see what your graph says. Drop your node and edge counts, or the most surprising hub, in the comments. And if this was useful, a ⭐ on &lt;a href="https://github.com/Graphify-Labs/graphify" rel="noopener noreferrer"&gt;GitHub&lt;/a&gt; helps more developers find it.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>knowledgegraph</category>
      <category>claudecode</category>
    </item>
    <item>
      <title>Why vector search isn't enough for coding agents</title>
      <dc:creator>Syed Fahad</dc:creator>
      <pubDate>Fri, 30 Oct 2026 16:21:05 +0000</pubDate>
      <link>https://dev.to/graphify/why-vector-search-isnt-enough-for-coding-agents-ai5</link>
      <guid>https://dev.to/graphify/why-vector-search-isnt-enough-for-coding-agents-ai5</guid>
      <description>&lt;p&gt;Ask a coding agent "where does an expired token get rejected?" and vector search will usually find something that sounds right. The hard part is the next step. The agent has to work out how that code connects to the code it's about to change.&lt;/p&gt;

&lt;p&gt;Since our post on &lt;a href="https://dev.to/graphify/code-knowledge-graph-vs-rag-why-structure-beats-similarity-4lo5"&gt;code knowledge graphs vs RAG&lt;/a&gt;, readers have asked for one thing above all: show it end to end. One question, the code it finds, the dependency path the graph returns, and a label on every hop saying whether it was read from the source or inferred. This post does exactly that. Everything below the "Worked example" heading is real output from open-source Graphify, run on a public repo you can clone yourself.&lt;/p&gt;

&lt;h2&gt;
  
  
  What others have already shown
&lt;/h2&gt;

&lt;p&gt;We're not the first to look at this, and the best published examples are worth reading in full:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The orphan function.&lt;/strong&gt; In &lt;a href="https://dev.to/wonderlab/codebase-knowledge-base-series-05-vector-retrieval-vs-knowledge-graph-adding-a-call-graph-4ad5"&gt;Codebase Knowledge Base Series (05)&lt;/a&gt;, WonderLab asks about "process payment". Vector top-5 returns &lt;code&gt;get_payment_history&lt;/code&gt; and &lt;code&gt;verify_webhook_signature&lt;/code&gt;, which look like payments but don't answer the question. One &lt;code&gt;CALLS&lt;/code&gt; hop from &lt;code&gt;process_checkout&lt;/code&gt; brings in &lt;code&gt;calculate_order_total&lt;/code&gt;, the function that does. In their words, it's "semantically distant but structurally close."&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The bug three hops down.&lt;/strong&gt; Tian Pan's &lt;a href="https://tianpan.co/blog/2026/05/07/code-specific-rag-general-retrieval-fails-codebases" rel="noopener noreferrer"&gt;Code-Specific RAG&lt;/a&gt; traces &lt;code&gt;processPayment → validateCard → checkFraudScore → fetchUserHistory&lt;/code&gt;. A query surfaces the first function, "but the actual bug or context lives in &lt;code&gt;fetchUserHistory&lt;/code&gt;. Token-based retrieval stops at the first hop."&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Look-alike functions.&lt;/strong&gt; In &lt;a href="https://www.inkylabai.com/articles/codebot" rel="noopener noreferrer"&gt;CodeBot&lt;/a&gt;, InkyLab points out that training and inference preprocessing "look almost identical. A vector search can't tell them apart." Their fix is resolved &lt;code&gt;calls&lt;/code&gt; edges over the Ultralytics codebase.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ranking by references.&lt;/strong&gt; &lt;a href="https://aider.chat/2023/10/22/repomap.html" rel="noopener noreferrer"&gt;Aider's repo map&lt;/a&gt; uses tree-sitter to pull out definitions and references, then ranks them on a dependency graph to fit a token budget.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;On a benchmark.&lt;/strong&gt; &lt;a href="https://arxiv.org/abs/2410.14684" rel="noopener noreferrer"&gt;RepoGraph&lt;/a&gt; (Ouyang et al.) builds a line-level definition/reference graph and retrieves ego-graphs around keywords. Plugged into four SWE-bench systems, it reports an average relative improvement of 32.8%.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;They all land in the same place. Finding the starting point is the easy part. Structure is how you get from there to everything the change touches. What most of these write-ups leave out is the question readers keep asking: &lt;strong&gt;how far can you trust each hop?&lt;/strong&gt; That's where Graphify's labelled edges come in.&lt;/p&gt;

&lt;h2&gt;
  
  
  Worked example: itsdangerous, one question
&lt;/h2&gt;

&lt;p&gt;The repo is &lt;a href="https://github.com/pallets/itsdangerous" rel="noopener noreferrer"&gt;pallets/itsdangerous&lt;/a&gt; (commit &lt;code&gt;672971d&lt;/code&gt;), the small library Flask uses to sign cookies and tokens. It's small enough to check every line by hand.&lt;/p&gt;

&lt;p&gt;Building the graph uses only the parser, with no LLM call:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;$ graphify update src
[graphify watch] Rebuilt: 152 nodes, 346 edges, 7 communities
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Step 1: the question finds the relevant code
&lt;/h3&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;$ graphify query "where does an expired timestamp raise SignatureExpired"
Graph: src/graphify-out/graph.json (152 nodes) | Traversal: BFS depth=2 |
Start: ['SignatureExpired', 'TimestampSigner', 'Raised if a signature does not match.'] | 64 nodes found
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;From a plain-language question, Graphify went straight to &lt;code&gt;SignatureExpired&lt;/code&gt; and &lt;code&gt;TimestampSigner&lt;/code&gt;, the code that handles expiry. A list of matching chunks would stop here. Graphify keeps going.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 2: the graph returns the path, with a label on every hop
&lt;/h3&gt;

&lt;p&gt;The same query returns the edges around those start nodes. Here are the ones that answer the question, copied as printed:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;EDGE TimestampSigner --method [EXTRACTED]--&amp;gt; .unsign() at=src/itsdangerous/timed.py:L72
EDGE .unsign() --calls [EXTRACTED context=call]--&amp;gt; SignatureExpired at=src/itsdangerous/timed.py:L142
EDGE SignatureExpired --inherits [EXTRACTED]--&amp;gt; BadTimeSignature at=src/itsdangerous/exc.py:L60
EDGE TimestampSigner --inherits [EXTRACTED]--&amp;gt; Signer at=src/itsdangerous/timed.py:L22
EDGE TimestampSigner --uses [INFERRED]--&amp;gt; SignatureExpired at=src/itsdangerous/timed.py:L142
EDGE TimedSerializer --uses [INFERRED]--&amp;gt; SignatureExpired at=src/itsdangerous/timed.py:L213
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then we ask for the shortest route from the serializer most apps actually call:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;$ graphify path "TimedSerializer" "SignatureExpired"
Shortest path (1 hops):
  TimedSerializer --uses [INFERRED]--&amp;gt; SignatureExpired
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Step 3: check each hop against the source
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;&lt;code&gt;.unsign() --calls--&amp;gt; SignatureExpired&lt;/code&gt;, EXTRACTED, timed.py:L142.&lt;/strong&gt; The parser read this straight from the call site:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;age&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;max_age&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="n"&gt;SignatureExpired&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That's the answer to the question, and it's backed by a line number.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;code&gt;SignatureExpired --inherits--&amp;gt; BadTimeSignature&lt;/code&gt;, EXTRACTED.&lt;/strong&gt; It's in the class definition. It also matters for the change: any &lt;code&gt;except BadTimeSignature&lt;/code&gt; or &lt;code&gt;except BadSignature&lt;/code&gt; will catch expiry too.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;code&gt;TimedSerializer --uses--&amp;gt; SignatureExpired&lt;/code&gt;, INFERRED, timed.py:L213.&lt;/strong&gt; No line has &lt;code&gt;TimedSerializer&lt;/code&gt; calling &lt;code&gt;SignatureExpired&lt;/code&gt;. The resolver linked them because the class body refers to the exception. Open line 213 and you'll find it isn't raised there. It's caught and re-raised:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;except&lt;/span&gt; &lt;span class="n"&gt;SignatureExpired&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="c1"&gt;# The signature was unsigned successfully but was
&lt;/span&gt;    &lt;span class="c1"&gt;# expired. Do not try the next signer.
&lt;/span&gt;    &lt;span class="k"&gt;raise&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The inferred edge points at exactly the right line, and the label tells the agent this is the one hop worth a quick look before it edits. That's the point of provenance. Without labels, every hop looks equally certain. With Graphify, the agent knows which hops are read straight from the source and which one to verify.&lt;/p&gt;

&lt;h3&gt;
  
  
  What the agent ends up knowing
&lt;/h3&gt;

&lt;p&gt;Say the task is "make expired tokens return a 401 instead of a 500." Here's what each approach hands the agent:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Graphify, with labelled hops:&lt;/strong&gt;

&lt;ul&gt;
&lt;li&gt;The exact raise site (L142, parser-backed).&lt;/li&gt;
&lt;li&gt;The exception hierarchy that decides which &lt;code&gt;except&lt;/code&gt; blocks catch it (parser-backed).&lt;/li&gt;
&lt;li&gt;The one place a serializer deliberately re-raises it (inferred, flagged to verify).&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Every hop comes with a file, a line number and a label, so the agent can make the change with the whole path in view.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why the graph matters
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Finding the code&lt;/strong&gt; answers "where is the code about X?"&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A code knowledge graph&lt;/strong&gt; answers "what does X call, what calls X, and what catches it?" That's the question behind most risky changes, and the one WonderLab, Tian Pan, InkyLab, Aider and RepoGraph all show similarity alone can't answer.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Provenance labels&lt;/strong&gt; tell the agent when it can move on and when to read the source first. &lt;code&gt;EXTRACTED&lt;/code&gt; means the edge was read directly from the source. &lt;code&gt;INFERRED&lt;/code&gt; means Graphify resolved it.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Graphify gives the agent all three in one answer.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it on your own repo
&lt;/h2&gt;

&lt;p&gt;The fastest way to try this is the hosted &lt;strong&gt;&lt;a href="https://app.graphify.com" rel="noopener noreferrer"&gt;Graphify app&lt;/a&gt;&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;To run it locally, use the Graphify CLI:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;uv tool &lt;span class="nb"&gt;install &lt;/span&gt;graphifyy
graphify &lt;span class="nb"&gt;install&lt;/span&gt;          &lt;span class="c"&gt;# sets up the skill for Claude Code; use --platform for other assistants&lt;/span&gt;
graphify update &lt;span class="nb"&gt;.&lt;/span&gt;         &lt;span class="c"&gt;# build the code graph&lt;/span&gt;
graphify query &lt;span class="s2"&gt;"where does an expired token get rejected?"&lt;/span&gt;
graphify path &lt;span class="s2"&gt;"TimedSerializer"&lt;/span&gt; &lt;span class="s2"&gt;"SignatureExpired"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;blockquote&gt;
&lt;p&gt;Codex uses &lt;code&gt;$graphify&lt;/code&gt; instead of &lt;code&gt;/graphify&lt;/code&gt;.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Over MCP, the same operations are available as &lt;code&gt;query_graph&lt;/code&gt;, &lt;code&gt;shortest_path&lt;/code&gt; and &lt;code&gt;get_node&lt;/code&gt;, so any MCP client can use them. The source is at &lt;a href="https://github.com/Graphify-Labs/graphify" rel="noopener noreferrer"&gt;github.com/Graphify-Labs/graphify&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What's next
&lt;/h2&gt;

&lt;p&gt;Next, we want to run the same trace on a larger repo with hundreds of inferred edges, and measure how often an &lt;code&gt;INFERRED&lt;/code&gt; hop holds up when you check it against the source. If you have a repo where vector search keeps sending your agent to the wrong place, tell us in the comments or on &lt;a href="https://discord.gg/graphify" rel="noopener noreferrer"&gt;Discord&lt;/a&gt;, and we'll trace it.&lt;/p&gt;

&lt;p&gt;Thanks to the authors linked above for publishing examples we could build on.&lt;/p&gt;

&lt;p&gt;Syed Fahad and the Graphify team&lt;/p&gt;

</description>
      <category>ai</category>
      <category>codingagents</category>
      <category>knowledgegraph</category>
      <category>devtools</category>
    </item>
    <item>
      <title>Graphify made it to GitHub's Octoverse 2026</title>
      <dc:creator>Syed Fahad</dc:creator>
      <pubDate>Wed, 28 Oct 2026 20:19:56 +0000</pubDate>
      <link>https://dev.to/graphify/graphify-made-it-to-githubs-octoverse-2026-a4a</link>
      <guid>https://dev.to/graphify/graphify-made-it-to-githubs-octoverse-2026-a4a</guid>
      <description>&lt;p&gt;We're in GitHub's &lt;a href="https://octoverse.github.com/" rel="noopener noreferrer"&gt;Octoverse 2026&lt;/a&gt;. I had to read it twice.&lt;/p&gt;

&lt;p&gt;Octoverse is GitHub's yearly look at what happened in open source. This year's &lt;a href="https://github.blog/news-insights/octoverse/octoverse-commits-pushes-reach-new-highs-in-2026-as-developers-build-with-agents/" rel="noopener noreferrer"&gt;report&lt;/a&gt; has a list of the most-engaged open source repositories, and &lt;a href="https://github.com/Graphify-Labs/graphify" rel="noopener noreferrer"&gt;Graphify-Labs/graphify&lt;/a&gt; is No. 7 on the single-vendor and product-led side. That's next to microsoft/vscode, anomalyco/opencode, and BerriAI/litellm. The report covers 1 October 2025 to 30 September 2026.&lt;/p&gt;

&lt;p&gt;Our first commit was 5 April 2026. Six months later, GitHub put us in its year-in-review.&lt;/p&gt;

&lt;h2&gt;
  
  
  Octoverse, built by the community
&lt;/h2&gt;

&lt;p&gt;Engagement means people. You starred the repo, filed issues, sent pull requests, answered questions in Discord, and wrote about Graphify on your own blogs. That's what this list counted.&lt;/p&gt;

&lt;p&gt;As of 29 October 2026, the repo has more than 137,000 stars and more than 13,000 forks. The &lt;code&gt;graphifyy&lt;/code&gt; package was downloaded from PyPI more than 1.6 million times in the last month.&lt;/p&gt;

&lt;p&gt;Two weeks ago we wrote about &lt;a href="https://graphify.com/blog/125000-github-stars" rel="noopener noreferrer"&gt;125,000 GitHub stars&lt;/a&gt;, and before that about &lt;a href="https://graphify.com/blog/eight-million-downloads-in-six-months" rel="noopener noreferrer"&gt;8 million PyPI downloads&lt;/a&gt;. Octoverse is GitHub telling the same story.&lt;/p&gt;

&lt;h2&gt;
  
  
  What doesn't change
&lt;/h2&gt;

&lt;p&gt;If you're new here: Graphify turns your codebase into a map your AI assistant can read, so its answers come from your actual code.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Your code is parsed on your machine.&lt;/li&gt;
&lt;li&gt;Every relationship is tagged &lt;a href="https://graphify.com/glossary/confidence-tags" rel="noopener noreferrer"&gt;&lt;code&gt;EXTRACTED&lt;/code&gt; or &lt;code&gt;INFERRED&lt;/code&gt;&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;You get a &lt;a href="https://graphify.com/blog/what-is-a-code-knowledge-graph" rel="noopener noreferrer"&gt;knowledge graph&lt;/a&gt; your assistant can query and walk.&lt;/li&gt;
&lt;li&gt;Graphify stays Apache 2.0.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Type &lt;code&gt;/graphify&lt;/code&gt; in Claude Code, Cursor, Gemini CLI, or Copilot (&lt;code&gt;$graphify&lt;/code&gt; in Codex), and you get a map of your codebase.&lt;/p&gt;

&lt;h2&gt;
  
  
  Beyond the repo: what's on graphify.com
&lt;/h2&gt;

&lt;p&gt;The open source engine runs on your machine, and that stays. graphify.com is where the same graph runs hosted, kept current for you.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://graphify.com/mcp" rel="noopener noreferrer"&gt;hosted Graphify MCP server&lt;/a&gt; gives Claude Code, Cursor, Codex, Copilot, and other agents one endpoint with an OAuth sign-in, so they query the graph instead of re-reading files. The &lt;a href="https://graphify.com/integrations" rel="noopener noreferrer"&gt;Graphify integrations page&lt;/a&gt; lists the assistants it works with and the tools your code comes in from. Hosted plans add pull request reviews and &lt;a href="https://graphify.com/formal-verification" rel="noopener noreferrer"&gt;formal verification&lt;/a&gt;, and a workspace can hold more than code, like a &lt;a href="https://graphify.com/blog/connect-google-drive" rel="noopener noreferrer"&gt;Google Drive folder&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://graphify.com/pricing" rel="noopener noreferrer"&gt;Graphify pricing&lt;/a&gt; starts with a free plan for one developer, then Pro, Teams, and Enterprise. &lt;a href="https://graphify.com/enterprise" rel="noopener noreferrer"&gt;Graphify Enterprise&lt;/a&gt; runs self-hosted or air-gapped, with SAML single sign-on. Pre-seed and seed teams can apply to the &lt;a href="https://graphify.com/startups" rel="noopener noreferrer"&gt;Graphify for Startups program&lt;/a&gt; for 50% off Teams.&lt;/p&gt;

&lt;p&gt;If you'd rather help build, &lt;a href="https://graphify.com/graphguild" rel="noopener noreferrer"&gt;GraphGuild&lt;/a&gt; is our community program for people who answer questions, write, and host events.&lt;/p&gt;

&lt;h2&gt;
  
  
  Thank you
&lt;/h2&gt;

&lt;p&gt;This one belongs to every contributor, every bug report, and everyone who told a teammate about Graphify. Thanks also to the GitHub team for the recognition and the artwork.&lt;/p&gt;

&lt;p&gt;If Graphify has helped you, &lt;a href="https://github.com/Graphify-Labs/graphify" rel="noopener noreferrer"&gt;star it on GitHub&lt;/a&gt;. It's the easiest way to tell us to keep going.&lt;/p&gt;

&lt;p&gt;Syed Fahad and the Graphify team&lt;/p&gt;

</description>
      <category>opensource</category>
      <category>github</category>
      <category>ai</category>
      <category>community</category>
    </item>
    <item>
      <title>Grounded answers: how Graphify tags what it knows</title>
      <dc:creator>Syed Fahad</dc:creator>
      <pubDate>Wed, 28 Oct 2026 12:27:07 +0000</pubDate>
      <link>https://dev.to/graphify/grounded-answers-how-graphify-tags-what-it-knows-51g9</link>
      <guid>https://dev.to/graphify/grounded-answers-how-graphify-tags-what-it-knows-51g9</guid>
      <description>&lt;p&gt;Confidence tags on a Graphify graph say how each edge was established, before an agent follows it. EXTRACTED means tree-sitter found the call, import, or definition in the syntax tree. INFERRED means a model connected it. AMBIGUOUS means the evidence did not resolve, and the edge stays flagged. Read the tag before you trust the hop.&lt;/p&gt;

&lt;h2&gt;
  
  
  What do the confidence tags mean?
&lt;/h2&gt;

&lt;p&gt;A &lt;a href="https://graphify.com/blog/what-is-a-code-knowledge-graph" rel="noopener noreferrer"&gt;code knowledge graph&lt;/a&gt; stores functions, classes, and docs as nodes. Calls, imports, and references are the edges between them. The edge is the claim the assistant walks. &lt;a href="https://graphify.com/glossary/confidence-tags" rel="noopener noreferrer"&gt;Confidence tags&lt;/a&gt; are the label on that claim. &lt;a href="https://graphify.com/concepts" rel="noopener noreferrer"&gt;How Graphify works&lt;/a&gt; builds the graph in two stages, and the tag says which stage produced the edge.&lt;/p&gt;

&lt;p&gt;EXTRACTED comes from the syntax tree. Graphify parses code on the machine with tree-sitter. The parser finds the call, the import, or the definition, and that edge is deterministic. Parse the same file again and the parser finds the same edge. No model sits in that step. The Cursor integration describes this tag as parsed from the AST.&lt;/p&gt;

&lt;p&gt;INFERRED is a connection a model made. Docs, PDFs, and recordings are not a tree of calls. (SQL schemas and Terraform are parsed, so their edges are EXTRACTED.) The model you configure joins a doc page to the service it describes, or a runbook to the Terraform resource it covers. Those edges are usually right. They are still a judgment, and the tag says so. A plausible link can be wrong. The tag is how you see that the link was proposed.&lt;/p&gt;

&lt;p&gt;AMBIGUOUS means Graphify found evidence and could not resolve it. The cases named in the glossary are dynamic dispatch, reflection, and an import built from a string. The edge stays in the graph with the flag, so the unresolved link is visible as unresolved.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;graphify explain&lt;/code&gt; shows how each connection on a node was established. &lt;code&gt;GRAPH_REPORT.md&lt;/code&gt; separates the architecture the parser extracted from the connections the model proposed. Over MCP, &lt;code&gt;graph_stats&lt;/code&gt; and the confidence audit in the report break the graph down by the three tags, so you can see how much of the map is parsed fact.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why should an agent read the tag before the next hop?
&lt;/h2&gt;

&lt;p&gt;An answer from the graph is a path. Each hop names a file and a line, and the edge on that hop carries one tag. The tags are different evidence. A caller the parser found and a doc the model attached can both appear in the same path, and the output keeps them distinct.&lt;/p&gt;

&lt;p&gt;Treat every hop as fact and an INFERRED link gets the same weight as an EXTRACTED call. That is how a guessed connection becomes an edit. The glossary uses this picture: the payment worker depends on the sessions table. You want to see whether the parser found that, or a model inferred it, before you change the code.&lt;/p&gt;

&lt;p&gt;Lean on an EXTRACTED hop when you change code. Treat an INFERRED hop as a lead, and open the doc and the symbol. Treat an AMBIGUOUS hop as a place to read the source, because the evidence stopped short of a resolved link.&lt;/p&gt;

&lt;p&gt;A similarity score says two chunks resemble each other. It does not record whether a relationship was parsed or proposed. That difference is the subject of &lt;a href="https://graphify.com/blog/code-knowledge-graph-vs-rag" rel="noopener noreferrer"&gt;Code knowledge graph vs RAG&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where do confidence tags not help?
&lt;/h2&gt;

&lt;p&gt;The tag describes an edge. It does not answer "find this string." Grep returns the lines that contain the string. A misspelled word in a comment, or a URL in a config file, is that question. Grep answers the hop you can phrase as a string. A tag will not.&lt;/p&gt;

&lt;p&gt;Fuzzy search over a large body of prose is the other miss. Embeddings are the better tool there, and Graphify does not try to beat them. A tag will not find the paragraph that only resembles the question.&lt;/p&gt;

&lt;h2&gt;
  
  
  What runs on the machine?
&lt;/h2&gt;

&lt;p&gt;The open-source engine is Apache 2.0. Code parsing happens on your machine. There is no telemetry. INFERRED edges use the model backend you configure, and that backend can be a local one, so the judgment can stay on the machine too. The graph is files in &lt;code&gt;graphify-out/&lt;/code&gt;: &lt;code&gt;graph.html&lt;/code&gt;, &lt;code&gt;GRAPH_REPORT.md&lt;/code&gt;, and &lt;code&gt;graph.json&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://app.graphify.com" rel="noopener noreferrer"&gt;Graphify Cloud&lt;/a&gt; hosts the same kind of graph and keeps it current. It is a different product.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;uv tool &lt;span class="nb"&gt;install &lt;/span&gt;graphifyy
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The package on PyPI is &lt;code&gt;graphifyy&lt;/code&gt; (two y's). &lt;code&gt;pipx install graphifyy&lt;/code&gt; also works. Then &lt;code&gt;graphify install&lt;/code&gt;, and in the assistant &lt;code&gt;/graphify .&lt;/code&gt;. The command reference is in the &lt;a href="https://docs.graphify.com" rel="noopener noreferrer"&gt;docs&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>rag</category>
      <category>opensource</category>
    </item>
    <item>
      <title>Why graphs beat vectors for agent memory</title>
      <dc:creator>Syed Fahad</dc:creator>
      <pubDate>Wed, 28 Oct 2026 12:26:57 +0000</pubDate>
      <link>https://dev.to/graphify/why-graphs-beat-vectors-for-agent-memory-m4a</link>
      <guid>https://dev.to/graphify/why-graphs-beat-vectors-for-agent-memory-m4a</guid>
      <description>&lt;p&gt;A code graph stores the calls and imports in a codebase, and the assistant still has them next session. A vector database stores text that resembles the question, then searches again. The code graph vs vector database difference is what the assistant remembers.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does a code graph differ from a vector database?
&lt;/h2&gt;

&lt;p&gt;A code graph stores typed entities and the relationships between them. A &lt;a href="https://graphify.com/glossary/knowledge-graph" rel="noopener noreferrer"&gt;Knowledge graph&lt;/a&gt; is that structure. The entities are the things in the repo. The edges are how they connect, and an assistant can traverse them. A vector database stores embeddings and metadata filters. A filter limits which vectors return. The relationship lives on the graph as an edge, and that edge is still there when the assistant starts again.&lt;/p&gt;

&lt;p&gt;How similarity and structure compare as ways to fetch an answer is in &lt;a href="https://graphify.com/blog/code-knowledge-graph-vs-rag" rel="noopener noreferrer"&gt;Code knowledge graph vs RAG&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What does a query return?
&lt;/h2&gt;

&lt;p&gt;A graph query is a typed, multi-hop traversal. The assistant follows edges of a given type, one hop after another. A vector query is approximate nearest-neighbour search, a top-k of the chunks whose embeddings sit nearest the question.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://graphify.com/vs/vector-databases" rel="noopener noreferrer"&gt;Graphify vs vector databases&lt;/a&gt; sets the two side by side. Pinecone, Weaviate, and pgvector return the most similar vectors. The graph returns the entities and the relationships between them. For an assistant, that result is the memory.&lt;/p&gt;

&lt;h2&gt;
  
  
  What happens on the second hop?
&lt;/h2&gt;

&lt;p&gt;The gap shows up when a question has two steps. A top-k lookup is one round of nearest-neighbour search, so a second hop needs the first answer before it can even be phrased. The model is left stitching disconnected chunks together.&lt;/p&gt;

&lt;p&gt;On a graph the second hop is one more edge. A later session follows that same edge, because the edge was stored with the graph.&lt;/p&gt;

&lt;h2&gt;
  
  
  What stays when a file changes?
&lt;/h2&gt;

&lt;p&gt;Changing a file means re-embedding and upserting every chunk it touched before any of it can be retrieved again. Graphify re-parses that one file and updates its nodes. The edges that did not change stay. The cost of keeping current is the size of the change, not the size of the repository.&lt;/p&gt;

&lt;p&gt;Inside the assistant, the command is &lt;code&gt;/graphify . --update&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  How can you check an answer?
&lt;/h2&gt;

&lt;p&gt;A vector result comes with a similarity score. The score measures how near two vectors were. A graph result is the path the answer took. Every edge on that path carries a confidence tag: EXTRACTED, INFERRED, or AMBIGUOUS.&lt;/p&gt;

&lt;p&gt;The tag is stored on the edge, so the next session can read that path.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where does the text go?
&lt;/h2&gt;

&lt;p&gt;Vector data is often shipped to an embedding API. Graphify is on-device, and it sends no telemetry.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where does a vector database still win?
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://graphify.com/vs/vector-databases" rel="noopener noreferrer"&gt;Graphify vs vector databases&lt;/a&gt; has nine rows. Eight of them are a real difference. The ninth is the one they win. A vector index answers what looks like this, and for fuzzy similarity over large volumes of prose it is still the better tool.&lt;/p&gt;

&lt;h2&gt;
  
  
  Can you run both?
&lt;/h2&gt;

&lt;p&gt;You can run both. Some teams keep a vector index for semantic recall and use Graphify for structure. Graphify can store embeddings as node attributes, so similarity stays one signal inside a traversal.&lt;/p&gt;

&lt;p&gt;Hybrid search blends keyword and vector scores. What comes back is still a ranked list of disconnected chunks. A graph returns connected entities, and the structure survives retrieval. &lt;a href="https://graphify.com/vs/rag" rel="noopener noreferrer"&gt;Graphify vs RAG&lt;/a&gt; is that choice for a retrieval pipeline. After the session ends, those connections are on the graph.&lt;/p&gt;

&lt;h2&gt;
  
  
  Does Graphify replace Pinecone, Weaviate, or pgvector?
&lt;/h2&gt;

&lt;p&gt;As coding-assistant memory, retrieval becomes a traversal over typed edges. The answer arrives as connected entities, and the path is there to read. Graphify does not replace Pinecone, Weaviate, or pgvector for every workload. Those products keep their place for pure similarity, and Graphify runs alongside them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Is Graphify a graph database like Neo4j?
&lt;/h2&gt;

&lt;p&gt;Graphify is a memory layer. It builds the graph from your codebase and serves it over MCP and the CLI. There is no schema to model and no queries to write. If you already run Neo4j or FalkorDB, it exports into them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Proof
&lt;/h2&gt;

&lt;p&gt;Steve Scargall, at MemVerge, reported 79× fewer tokens on a 496K-token codebase, with no vector database in the stack. That is his measurement, not a Graphify benchmark.&lt;/p&gt;

&lt;h2&gt;
  
  
  Install
&lt;/h2&gt;

&lt;p&gt;The package on PyPI is &lt;code&gt;graphifyy&lt;/code&gt;. Install the CLI, then register it with your assistant.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;uv tool &lt;span class="nb"&gt;install &lt;/span&gt;graphifyy
graphify &lt;span class="nb"&gt;install&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;In the project, build the graph.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/graphify .
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



</description>
      <category>ai</category>
      <category>rag</category>
      <category>agents</category>
      <category>llm</category>
    </item>
    <item>
      <title>How to give GitHub Copilot codebase context that persists</title>
      <dc:creator>Syed Fahad</dc:creator>
      <pubDate>Wed, 28 Oct 2026 12:26:29 +0000</pubDate>
      <link>https://dev.to/graphify/how-to-give-github-copilot-codebase-context-that-persists-4f0f</link>
      <guid>https://dev.to/graphify/how-to-give-github-copilot-codebase-context-that-persists-4f0f</guid>
      <description>&lt;p&gt;GitHub Copilot codebase context vanishes when the chat ends, because each session starts from zero and Copilot searches the repo again. A graph built once on your machine is a map Copilot can query the next time. Graphify builds that graph and registers it with Copilot.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do you give GitHub Copilot codebase context?
&lt;/h2&gt;

&lt;p&gt;The &lt;a href="https://graphify.com/integrations/github-copilot" rel="noopener noreferrer"&gt;GitHub Copilot integration&lt;/a&gt; page wires this in two commands, then a graph of the repo. The package on PyPI is &lt;code&gt;graphifyy&lt;/code&gt; (two y's).&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;uv tool &lt;span class="nb"&gt;install &lt;/span&gt;graphifyy
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;pipx install graphifyy&lt;/code&gt; also works.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;graphify &lt;span class="nb"&gt;install&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;graphify install&lt;/code&gt; registers the &lt;code&gt;/graphify&lt;/code&gt; skill and an MCP server, so Copilot can query the graph. Graphify speaks the &lt;a href="https://modelcontextprotocol.io" rel="noopener noreferrer"&gt;Model Context Protocol&lt;/a&gt;. Any MCP client talks to the same server and the same ten graph tools. The integration page points at the docs for how to point Copilot at that server.&lt;/p&gt;

&lt;p&gt;Build the graph on the project you have open. In Copilot, run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/graphify .
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Tree-sitter parses the code locally, so call and import edges come from the syntax tree. Docs and other non-code files are read by the model you already use. The map lands in &lt;code&gt;graphify-out/&lt;/code&gt; as &lt;code&gt;graph.html&lt;/code&gt;, &lt;code&gt;GRAPH_REPORT.md&lt;/code&gt;, and &lt;code&gt;graph.json&lt;/code&gt;. The next session queries those files. The architecture is already on disk.&lt;/p&gt;

&lt;p&gt;A &lt;a href="https://graphify.com/glossary/knowledge-graph" rel="noopener noreferrer"&gt;knowledge graph&lt;/a&gt; here means entities and the typed relationships between them. The same shape of setup for Cursor is &lt;a href="https://graphify.com/blog/how-to-give-cursor-a-code-knowledge-graph" rel="noopener noreferrer"&gt;How to give Cursor a code knowledge graph&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What can Copilot ask once the graph exists?
&lt;/h2&gt;

&lt;p&gt;The questions on the integration page are the ones that used to mean reading a large slice of the repo. What calls &lt;code&gt;chargeCustomer&lt;/code&gt;, and what breaks if the signature changes. The path from a checkout endpoint to the table it writes. Which modules read a config value such as &lt;code&gt;STRIPE_KEY&lt;/code&gt;. How the auth subsystem hangs together before you touch it.&lt;/p&gt;

&lt;p&gt;You can run the same questions from the shell. The page names these commands:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;graphify query &lt;span class="s2"&gt;"what calls chargeCustomer"&lt;/span&gt;
graphify path &lt;span class="s2"&gt;"checkout"&lt;/span&gt; &lt;span class="s2"&gt;"database"&lt;/span&gt;
graphify explain &lt;span class="s2"&gt;"AuthService"&lt;/span&gt;
graphify prs
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;graphify query&lt;/code&gt; returns a scoped piece of the graph. &lt;code&gt;graphify path&lt;/code&gt; walks the hops between two nodes. &lt;code&gt;graphify explain&lt;/code&gt; lists the edges on one symbol. &lt;code&gt;graphify prs&lt;/code&gt; is the pull-request command listed beside them. The docs cover its flags.&lt;/p&gt;

&lt;p&gt;Every edge Copilot gets back carries a confidence tag. EXTRACTED was parsed from the AST with tree-sitter. INFERRED means a model connected non-code material, such as a doc to the service it describes, and the tag marks that judgment. AMBIGUOUS means there was evidence and it could not be fully resolved, as with dynamic dispatch or an import built from a string. The edge is kept and flagged.&lt;/p&gt;

&lt;p&gt;When Copilot returns a path, open the file and line on the hop you are about to trust, and read the tag on that edge. An EXTRACTED edge is the parser. An INFERRED edge is the model joining a doc or a schema to code. It can be wrong and still sound plausible. An AMBIGUOUS edge is unresolved evidence, kept so the gap stays visible. The integration page describes the return value as connected structure, a path, which still holds past one or two hops. A pile of matching files, with the links guessed in the chat, is the loop this replaces.&lt;/p&gt;

&lt;h2&gt;
  
  
  What does the graph leave to you?
&lt;/h2&gt;

&lt;p&gt;The graph does not update itself. After the code changes, run &lt;code&gt;/graphify .&lt;/code&gt; again, or &lt;code&gt;/graphify . --update&lt;/code&gt; to re-scan only what changed. From the shell, &lt;code&gt;graphify update .&lt;/code&gt; does that pass. &lt;code&gt;graphify hook install&lt;/code&gt; adds post-commit and post-checkout git hooks that refresh the changed files. Until you refresh, Copilot is reading the last map you built.&lt;/p&gt;

&lt;p&gt;Grep still wins when the question is "find this string." The graph is for relationships. A literal string in a comment is still a search.&lt;/p&gt;

&lt;p&gt;The open-source engine runs on your machine. Code parsing is local. There is no telemetry. &lt;a href="https://app.graphify.com" rel="noopener noreferrer"&gt;Graphify Cloud&lt;/a&gt; is the hosted graph. This guide is the on-device setup. Cloud is a different product.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do you confirm it is wired?
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;uv tool &lt;span class="nb"&gt;install &lt;/span&gt;graphifyy
graphify &lt;span class="nb"&gt;install&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then, in Copilot:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/graphify .
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The command reference is in the &lt;a href="https://docs.graphify.com" rel="noopener noreferrer"&gt;docs&lt;/a&gt;. Copilot-specific notes stay on the &lt;a href="https://graphify.com/integrations/github-copilot" rel="noopener noreferrer"&gt;GitHub Copilot integration&lt;/a&gt; page.&lt;/p&gt;

</description>
      <category>githubcopilot</category>
      <category>ai</category>
      <category>devtools</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Best codebase-context tools for AI coding assistants (2026)</title>
      <dc:creator>Syed Fahad</dc:creator>
      <pubDate>Wed, 28 Oct 2026 12:26:19 +0000</pubDate>
      <link>https://dev.to/graphify/best-codebase-context-tools-for-ai-coding-assistants-2026-1j7p</link>
      <guid>https://dev.to/graphify/best-codebase-context-tools-for-ai-coding-assistants-2026-1j7p</guid>
      <description>&lt;p&gt;The best codebase context tools depend on the question you are asking. Grep finds a string. Embeddings, RAG, and a vector database find prose that resembles the question. A code knowledge graph follows a relationship you can open. Hosted search and review tools serve a person, or a pull request.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Question&lt;/th&gt;
&lt;th&gt;A tool that fits&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Find this string&lt;/td&gt;
&lt;td&gt;grep&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Prose that resembles the question&lt;/td&gt;
&lt;td&gt;Embeddings, RAG, or a vector database&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;What calls what, hop by hop&lt;/td&gt;
&lt;td&gt;A code knowledge graph&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Search across the organisation&lt;/td&gt;
&lt;td&gt;Sourcegraph&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Comments on an open pull request&lt;/td&gt;
&lt;td&gt;Greptile or CodeRabbit&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Code that looks like this, inside Cursor&lt;/td&gt;
&lt;td&gt;Cursor's own index&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  What is grep best at?
&lt;/h2&gt;

&lt;p&gt;Grep is best when the question is "find this string." It returns the lines that contain the text. One hop is usually in reach too: the direct callers of a function, when the name in the call matches the name you searched.&lt;/p&gt;

&lt;p&gt;Past that hop, text search gets worse. A question such as what breaks if this schema changes runs through the table, the queries, the services, and the endpoints. Each hop adds name collisions, re-exports, and files that mention the symbol without touching it.&lt;/p&gt;

&lt;h2&gt;
  
  
  What are embeddings, RAG, and a vector database best at?
&lt;/h2&gt;

&lt;p&gt;They are best at fuzzy recall over prose. &lt;a href="https://graphify.com/vs/rag" rel="noopener noreferrer"&gt;Graphify vs RAG&lt;/a&gt; describes retrieval-augmented generation the way Lewis et al. (2020) introduced it: split documents into chunks, embed them, and pull back the top-k most similar. That works for lookup, when the answer sits in one passage.&lt;/p&gt;

&lt;p&gt;A relationship is a different shape. Chunking drops the link between a function and its caller. A two-hop question needs the first answer before the second can be asked, which is why benchmarks such as HotpotQA exist. &lt;a href="https://graphify.com/vs/vector-databases" rel="noopener noreferrer"&gt;Graphify vs vector databases&lt;/a&gt; names Pinecone, Weaviate, and pgvector: nearest-neighbour search returns similar vectors. A metadata filter narrows that search. Hybrid search still comes back as a ranked list of disconnected chunks.&lt;/p&gt;

&lt;p&gt;A changed file is re-embedded before those chunks can be retrieved again. A similarity score measures resemblance, and you judge the answer yourself. Chunks in a typical embedding pipeline go to an embedding API.&lt;/p&gt;

&lt;p&gt;Keep the vector index when the corpus is prose. Some teams run both: vectors for semantic recall, a graph for relationships. Graphify can store an embedding as one signal on a node, and retrieval is still a walk. If you already run Neo4j or FalkorDB, the graph exports into them. The essay form of this argument is &lt;a href="https://graphify.com/blog/code-knowledge-graph-vs-rag" rel="noopener noreferrer"&gt;Code knowledge graph vs RAG&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is a code knowledge graph best at?
&lt;/h2&gt;

&lt;p&gt;A code knowledge graph is best when the assistant needs a relationship: what calls this, what a change reaches, the path from one symbol to another. Graphify builds that graph from the repo. Code is parsed on the machine with tree-sitter, and each edge carries a confidence tag: EXTRACTED from the syntax tree, INFERRED by a model, or AMBIGUOUS when the evidence did not resolve. An answer is a path you can open.&lt;/p&gt;

&lt;p&gt;There is no telemetry on the open-source engine. &lt;a href="https://app.graphify.com" rel="noopener noreferrer"&gt;Graphify Cloud&lt;/a&gt; is the hosted graph. It is a different product.&lt;/p&gt;

&lt;p&gt;Graphify is the wrong tool for two of the jobs in the table. Fuzzy prose still belongs to embeddings. "Find this string" still belongs to grep.&lt;/p&gt;

&lt;h2&gt;
  
  
  What are hosted search and review tools best at?
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://graphify.com/vs/sourcegraph" rel="noopener noreferrer"&gt;Graphify vs Sourcegraph&lt;/a&gt; is a code search platform people use. The index covers the organisation, every repository, cloud or self-hosted, under a commercial licence. Search across thousands of repositories is the job that page says Sourcegraph is built for. Graphify maps the repositories you point it at, on the machine where you work, and the assistant walks that map. The two can run together.&lt;/p&gt;

&lt;p&gt;Greptile is hosted review and codebase chat. It indexes your code, and you see pull-request comments plus its own chat. Managed review on every pull request is its core product. &lt;code&gt;graphify prs&lt;/code&gt; is on demand. A managed bot that fits your policies is Greptile's job. A graph on the machine fits when the code cannot leave, or when you want each claim auditable.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://graphify.com/vs/cursor" rel="noopener noreferrer"&gt;Graphify vs Cursor indexing&lt;/a&gt; is the page whose answer is to use both. Cursor's index is embedding similarity inside the editor, automatic, with indexing through Cursor's servers. It surfaces code that looks like what you half remember, and there is nothing to set up. Connected questions are where it runs out. "What breaks if I change this" is a caller of a caller, and the model stitches similar snippets. You also cannot inspect why a snippet was pulled in. Graphify registers as an MCP server, the built-in index stays on, and the agent uses the graph when the question is structural.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://graphify.com/vs/coderabbit" rel="noopener noreferrer"&gt;Graphify vs CodeRabbit&lt;/a&gt; acts after the pull request opens: comments in GitHub or GitLab, through a hosted service, once the change is already written. Graphify is for the assistant writing the code, so it can ask what calls this before the edit. Graph-aware review in Graphify is Enterprise, early access, running in your own infrastructure. For a managed bot on every pull request today, that page says a service is the right shape. A common setup is the graph on the machine while code is written, and a hosted reviewer on the pull requests that follow.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>devtools</category>
      <category>opensource</category>
      <category>productivity</category>
    </item>
    <item>
      <title>How to give Cursor a code knowledge graph (2026 guide)</title>
      <dc:creator>Syed Fahad</dc:creator>
      <pubDate>Wed, 28 Oct 2026 12:26:10 +0000</pubDate>
      <link>https://dev.to/graphify/how-to-give-cursor-a-code-knowledge-graph-2026-guide-3g1b</link>
      <guid>https://dev.to/graphify/how-to-give-cursor-a-code-knowledge-graph-2026-guide-3g1b</guid>
      <description>&lt;p&gt;Out of the box, Cursor answers codebase questions by searching. It greps for a symbol, opens the files that match, reads them into context, and assembles an answer. That works, and it is expensive in a specific way. The exploration repeats every session, the same files get re-read, and the architectural picture the agent builds is gone the moment you close the window.&lt;/p&gt;

&lt;p&gt;A &lt;a href="https://graphify.com/glossary/knowledge-graph" rel="noopener noreferrer"&gt;code knowledge graph&lt;/a&gt; changes the move available to the agent. Instead of re-deriving structure from text, Cursor queries a persistent map of your repo: functions, classes, tables, and config as nodes; calls, imports, and references as typed edges. The graph is built once and stored on your machine. Graphify is the open-source (Apache 2.0) tool that builds that graph and hands it to Cursor. The whole setup is four commands.&lt;/p&gt;

&lt;h2&gt;
  
  
  How it works
&lt;/h2&gt;

&lt;p&gt;Install the CLI. The package on PyPI is &lt;code&gt;graphifyy&lt;/code&gt; (two y's). That puts the &lt;code&gt;graphify&lt;/code&gt; command on your path.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;uv tool &lt;span class="nb"&gt;install &lt;/span&gt;graphifyy
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Wire Cursor. &lt;code&gt;graphify install&lt;/code&gt; detects Cursor and registers Graphify over the &lt;a href="https://modelcontextprotocol.io" rel="noopener noreferrer"&gt;Model Context Protocol&lt;/a&gt;, the open standard Cursor already speaks for external tools. Cursor's agent can then call the graph mid-conversation: query the structure, trace a path between two nodes, explain why a node matters. No config files to hand-edit. The &lt;a href="https://graphify.com/integrations/cursor" rel="noopener noreferrer"&gt;Cursor integration page&lt;/a&gt; has the specifics.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;graphify &lt;span class="nb"&gt;install&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Map the repo. In your next agent session, or from the shell, run &lt;code&gt;/graphify .&lt;/code&gt; in the project. Graphify parses your code locally across about 40 languages, including SQL, Postgres schemas, and Terraform, so the call and import edges come from real AST extraction. No model is involved in reading your source. Docs and PDFs are folded in by whichever model you choose.&lt;/p&gt;

&lt;p&gt;A few minutes later, three files sit in &lt;code&gt;graphify-out/&lt;/code&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;graph.html&lt;/code&gt;: an interactive map you can open in a browser&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;GRAPH_REPORT.md&lt;/code&gt;: a written brief covering god nodes, subsystem communities, and suggested questions&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;graph.json&lt;/code&gt;: the raw structure&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Ask structural questions. Try the ones that used to trigger long search-and-read loops: what calls this function, what is the blast radius of renaming this column, how does the webhook handler reach the database. Cursor answers by traversing the graph (a handful of nodes and edges rather than the full text of every matching file). Every edge carries a provenance tag: &lt;code&gt;EXTRACTED&lt;/code&gt; from the AST, &lt;code&gt;INFERRED&lt;/code&gt; by the model, or &lt;code&gt;AMBIGUOUS&lt;/code&gt; when the evidence could not be resolved. Why that tagging matters is in &lt;a href="https://graphify.com/concepts" rel="noopener noreferrer"&gt;concepts&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;You can run the same queries yourself:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;graphify query &lt;span class="s2"&gt;"what calls this handler"&lt;/span&gt;
graphify path &lt;span class="s2"&gt;"webhook"&lt;/span&gt; &lt;span class="s2"&gt;"database"&lt;/span&gt;
graphify explain &lt;span class="s2"&gt;"APIRouter"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The command reference lives in the &lt;a href="https://docs.graphify.com" rel="noopener noreferrer"&gt;docs&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  The limit
&lt;/h2&gt;

&lt;p&gt;The open-source engine runs on your machine. Code parsing is local. There is no telemetry. The only optional network call is the model used to fold non-code sources into the graph, and that can stay local with Ollama.&lt;/p&gt;

&lt;p&gt;Re-run &lt;code&gt;/graphify .&lt;/code&gt; when the code changes meaningfully, or &lt;code&gt;graphify . --update&lt;/code&gt; to re-scan only what changed. Between refreshes the graph is plain files in &lt;code&gt;graphify-out/&lt;/code&gt;. It does not update itself.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://app.graphify.com" rel="noopener noreferrer"&gt;Graphify Cloud&lt;/a&gt; is the hosted, always-on graph: the same map, kept current across repos, queryable from any assistant. This guide is the on-device setup. Cloud is a different product.&lt;/p&gt;

&lt;p&gt;This does not replace Cursor's grep. It gives the agent a map to consult first. For a question that is really "find this string," grep is still the right tool.&lt;/p&gt;

&lt;h2&gt;
  
  
  Proof
&lt;/h2&gt;

&lt;p&gt;Graph answers are small, and the graph persists, so context stops being spent on re-discovery. Actual savings depend on your repo and your questions. One community user reported 71.5× fewer tokens on their workload. That is their measurement, not a Graphify benchmark. The claim underneath it is that a traversal sends less text than a file dump.&lt;/p&gt;

&lt;p&gt;The other change is qualitative. Because every answer traces to a path through real files, you can audit what Cursor tells you instead of taking a plausible-sounding reconstruction on faith. Open &lt;code&gt;GRAPH_REPORT.md&lt;/code&gt; once. The god nodes and subsystem communities it names are usually worth knowing about even before the agent starts using them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Install
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;uv tool &lt;span class="nb"&gt;install &lt;/span&gt;graphifyy
graphify &lt;span class="nb"&gt;install&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then, in Cursor:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/graphify .
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;First-graph walkthrough: &lt;a href="https://docs.graphify.com/guides/first-graph" rel="noopener noreferrer"&gt;docs.graphify.com/guides/first-graph&lt;/a&gt;. Cursor-specific notes: &lt;a href="https://graphify.com/integrations/cursor" rel="noopener noreferrer"&gt;graphify.com/integrations/cursor&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>cursor</category>
      <category>mcp</category>
      <category>ai</category>
      <category>tutorial</category>
    </item>
  </channel>
</rss>
