Persistent Knowledge Graph for Codebases with Codebase-MCP | Sumanth P님이 토픽에 대해 올림

Persistent Knowledge Graph for Codebases with Codebase-MCP

이 제목은 아래 게시물에서 AI가 요약한 것입니다.

Give your AI agent a persistent knowledge graph of your entire codebase! Most AI coding agents read files when you point them at something. They have no structural understanding of your codebase, no idea what calls what, and they start from scratch every session. codebase-memory-mcp builds a persistent knowledge graph of your entire codebase that your agent can query in under 1ms. An average repo indexes in milliseconds. The Linux kernel, 28 million lines across 75,000 files, takes 3 minutes. Five structural queries run at around 3,400 tokens compared to 412,000 for file-by-file grep exploration. What it gives your agent: • 158 languages via vendored tree-sitter grammars compiled into a single static binary, zero dependencies • Hybrid LSP semantic type resolution for Python, TypeScript, JavaScript, PHP, C#, Go, C, C++, Java, Kotlin, Rust, and Perl, building call graphs that understand inheritance, generics, and cross-file imports • 15 MCP tools covering search, trace, architecture overview, impact analysis, dead code detection, Cypher queries, and cross-service HTTP linking • Auto-sync via a background watcher that detects file changes and re-indexes automatically • Team-shared graph artifact via a compressed SQLite snapshot you commit to the repo so teammates skip the reindex • Built-in 3D graph visualization • Configures itself for Claude Code, Codex CLI, Gemini CLI, Zed, OpenCode, Aider, KiloCode, VS Code, OpenClaw, Kiro, and 33 more agent surfaces with one install command 100% open source. Link to the GitHub repo in the comments!

댓글 21

wondering how the sub-1ms holds once the graph gets big, since 75,000 files on the linux kernel is still a lot of nodes to traverse per query. an index like that usually needs something closer to an embedded graph store, rocksdb-backed adjacency lists or similar, to keep lookups flat instead of degrading with repo size. auto-sync on file change is the harder problem though, curious if the watcher does incremental re-parsing per file or falls back to a partial reindex.추천[

댓글

](https://www.linkedin.com/signup/cold-join?session_redirect=https%3A%2F%2Fwww%2Elinkedin%2Ecom%2Fposts%2Fsumanth077_give-your-ai-agent-a-persistent-knowledge-activity-7488956462459879424-W2ce&trk=public_post_comment_reply)[반응 6](https://www.linkedin.com/signup/cold-join?session_redirect=https%3A%2F%2Fwww%2Elinkedin%2Ecom%2Fposts%2Fsumanth077_give-your-ai-agent-a-persistent-knowledge-activity-7488956462459879424-W2ce&trk=public_post_comment_reactions)

더 보기

댓글을 보거나 남기려면 로그인

관련성이 더 높은 업데이트

  • Give your AI agent a persistent knowledge graph of your entire codebase! Most AI coding agents read files when you point them at something. They have no structural understanding of your codebase, no idea what calls what, and they start from scratch every session. codebase-memory-mcp builds a persistent knowledge graph of your entire codebase that your agent can query in under 1ms. An average repo indexes in milliseconds. The Linux kernel, 28 million lines across 75,000 files, takes 3 minutes. Five structural queries run at around 3,400 tokens compared to 412,000 for file-by-file grep exploration. What it gives your agent: • 158 languages via vendored tree-sitter grammars compiled into a single static binary, zero dependencies • Hybrid LSP semantic type resolution for Python, TypeScript, JavaScript, PHP, C#, Go, C, C++, Java, Kotlin, and Rust, building call graphs that understand inheritance, generics, and cross-file imports • 14 MCP tools covering search, trace, architecture overview, impact analysis, dead code detection, Cypher queries, and cross-service HTTP linking • Auto-sync via a background watcher that detects file changes and re-indexes automatically • Louvain community detection for discovering functional modules by clustering call edges • Team-shared graph artifact via a compressed SQLite snapshot you commit to the repo so teammates skip the reindex • Built-in 3D graph visualization at localhost:9749 in the UI variant • Configures itself for Claude Code, Codex CLI, Gemini CLI, Zed, OpenCode, Antigravity, Aider, KiloCode, VS Code, OpenClaw, and Kiro with one install command GitHub repo in the comments. _____ ♻️ Repost to share with your network ➕Join 24,500+ AI/ML builders here: https://lnkd.in/gfkzKZYk 댓글 11 댓글을 보거나 남기려면 로그인
  • 𝗛𝗼𝘄 𝗺𝗮𝗻𝘆 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝘄𝗮𝘆𝘀 𝗰𝗮𝗻 𝘆𝗼𝘂 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗿𝘂𝗻 𝗮 𝘀𝗶𝗻𝗴𝗹𝗲 𝗽𝗿𝗼𝗴𝗿𝗮𝗺? (Part 3) In Part 2, we pushed Compiled Systems to their absolute limits. Now, we enter the world of mathematical elegance and interactive evaluation: the Functional & ML Family. We often think of functional languages as strictly tied to heavy REPL sessions or academic compiled pipelines. But when you automate them in CI, you discover incredible ways to execute pure logic on the fly—from one-shot shell evaluations to piped expressions and shebang-friendly script runners. I catalogued all of them — runnable, validated, and continuously integrated via live CI pipelines. ━━━━━━━━━━━━━━━━━ 𝗜𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗶𝗻𝗴: 𝟰𝟵 𝗟𝗮𝗻𝗴𝘂𝗮𝗴𝗲𝘀, 𝗢𝗻𝗲 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻 — 𝗮𝗻 𝟴-𝗽𝗮𝗿𝘁 𝘀𝗲𝗿𝗶𝗲𝖘 (Link to previous posts for Parts 1 & 2 in the comments below!) ━━━━━━━━━━━━━━━━━ 𝗣𝗮𝗿𝘁 𝟯 — 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 & 𝗠𝗟 𝗙𝗮𝗺𝗶𝗹𝘆 Seven languages. 20 completely distinct validated entry points. Here is the breakdown of execution methods discovered across the repository: ▸ Haskell: 4 ways (Interpret-and-run scripts via runghc, binary compilation, and REPL heredocs) ▸ OCaml: 3 ways (Direct file interpreters, ocaml piped standard input expressions, and heredoc evaluations) ▸ F#: 3 ways (dotnet fsi script execution, emulated inline expressions, and temp file evaluations) ▸ Elixir: 3 ways (.exs scripts, inline -e executions, and iex one-shot interactive sessions) ▸ Scheme (Guile): 3 ways (File execution, -c inline expressions, and piped standard input streams) ▸ Common Lisp: 2 ways (sbcl —script mode, and non-interactive chained —eval flags) ▸ Erlang: 2 ways (escript shebang runners, and erl -noshell one-liners) For the full detailed breakdown and code snippets with links to their exact CI workflow source files, check the attached carousel PDF document below. ━━━━━━━━━━━━━━━━━ Comment “FUNCTIONAL” and I’ll tag you when Part 4 (Scripting & Glue) drops! 댓글 2 댓글을 보거나 남기려면 로그인
  • “Everyone talks about AI rewriting code. Almost no one talks about how you prove it actually works.” Software Development done right, at scale! Everyone talks about AI rewriting code. Almost no one talks about how you prove it actually works. So I tested it end to end — on a real app, documented every step. I took Kanboard (a popular open-source project stuck on PHP 7.4) and did a full rewrite to Python — FastAPI + SQLModel, same JSON-RPC API, strangler pattern. With no official Python version to grade against, a black-box behavioral test harness became my single source of truth. Then I let two tools play to their strengths: 🔹 Yardstick first — built a behavioral test harness with Kiro before touching the rewrite. 🔹 Transform at scale — ran the bulk PHP→Python rewrite with AWS Transform Custom, using the harness as its validation gate. Continual learning kicked in between runs. 🔹 Last mile — Kiro finished the features the harness couldn’t grade, verified with a side-by-side shadow run. Honest coverage, not a suspiciously perfect number. The lesson? The magic isn’t one tool — it’s the pairing. Transform does the heavy, at-scale work. Kiro builds the safety net and closes the gap. Together they turn “trust me, the AI did it” into “here’s the proof.” Full 3-part write-up: https://lnkd.in/gCSMMufA 📖 https://lnkd.in/gV_tzDTw 📖 https://lnkd.in/gFfAyker Modernization doesn’t have to be a leap of faith. Build the yardstick, then let the machines run. Joseph Cudby Avinash Nidumbur Svetlana Kolomeyskaya Purvin Vakharwala Derek Chiles Moshe Barlev Ritik Khatwani Renuka Krishnan Artur Rodrigues Ali Maaz Adnan Bilwani Jas Chhabra Elio Damaggio Sriram Devanathan Varun Kulkarni Brian Beach #AWSTransform #Kiro #CodeModernization #GenAI #LegacyModernization 댓글을 보거나 남기려면 로그인
  • Everyone talks about AI rewriting code. Almost no one talks about how you prove it actually works. So I tested it end to end — on a real app, documented every step. I took Kanboard (a popular open-source project stuck on PHP 7.4) and did a full rewrite to Python — FastAPI + SQLModel, same JSON-RPC API, strangler pattern. With no official Python version to grade against, a black-box behavioral test harness became my single source of truth. Then I let two tools play to their strengths: 🔹 Yardstick first — built a behavioral test harness with Kiro before touching the rewrite. 🔹 Transform at scale — ran the bulk PHP→Python rewrite with AWS Transform Custom, using the harness as its validation gate. Continual learning kicked in between runs. 🔹 Last mile — Kiro finished the features the harness couldn’t grade, verified with a side-by-side shadow run. Honest coverage, not a suspiciously perfect number. The lesson? The magic isn’t one tool — it’s the pairing. Transform does the heavy, at-scale work. Kiro builds the safety net and closes the gap. Together they turn “trust me, the AI did it” into “here’s the proof.” Full 3-part write-up: https://lnkd.in/gCSMMufA 📖 https://lnkd.in/gV_tzDTw 📖 https://lnkd.in/gFfAyker Modernization doesn’t have to be a leap of faith. Build the yardstick, then let the machines run. Joseph Cudby Avinash Nidumbur Svetlana Kolomeyskaya Purvin Vakharwala Derek Chiles Moshe Barlev Ritik Khatwani Renuka Krishnan Artur Rodrigues Ali Maaz Adnan Bilwani Jas Chhabra Elio Damaggio Sriram Devanathan Varun Kulkarni Brian Beach #AWSTransform #Kiro #CodeModernization #GenAI #LegacyModernization 댓글을 보거나 남기려면 로그인
  • So we decided to build the thing and see if the idea actually held up. FlowMCP is an attempt to build MCPs around reusable workflows instead of sprawling tool surfaces. The model still decides what needs to happen, selects the correct flow and supplies the required inputs. But once the workflow starts, the known steps are handled by deterministic software instead of asking the model to figure out the same execution path every time. That is the theory anyway. I still do not know if this is the answer, or if I spent a day over-engineering something that could have been a Python script. So I tested it. I ran models of different sizes against several MCP configurations, including raw tool surfaces, tool search, written recipes and prebuilt flows. The goal was not to prove FlowMCP was amazing. It was to test the original claim: Does reducing the model’s tool-selection and execution burden make the workflow more reliable? The benchmark report is here: https://lnkd.in/epHneHzu The report itself was synthesized with AI. The tests were selected and run by me, the outputs were reviewed by me, and I decided which conclusions the results actually supported. The model was just extremely useful for turning all of that into something readable. The early results are interesting. Now I need to see whether it can survive real workflows, messy APIs and failure paths that were not designed for a benchmark. Because that is where this either becomes useful or falls apart. 댓글 1 댓글을 보거나 남기려면 로그인
  • 𝗖𝗿𝗲𝗮𝘁𝗲 𝗔 𝗖𝘂𝘀𝘁𝗼𝗺 𝗔𝗜 𝗣𝗥 𝗥𝗲𝘃𝗶𝗲𝘄𝗲𝗿 𝗪𝗶𝘁𝗵 𝗚𝗶𝘁𝗛𝘂𝗯 𝗔𝗰𝘁𝗶𝗼𝗻𝘀 You do not need expensive third-party platforms to review your code. You can build your own AI code reviewer inside GitHub Actions. This setup uses a Python script and the Gemini API to act like a senior engineer on your team. Here is how the system works: • Trigger on PR Events: The workflow starts when you open or update a pull request. • Extract the Git Diff: The system pulls the code changes and trims them to stay within API limits. • Send to Gemini: A Python script sends the diff to the Gemini API using a structured JSON schema. • Post Inline Comments: The system automatically adds comments to specific lines in your PR. Why this approach works: - Precision: The script parses diff headers to ensure the AI only comments on lines you actually changed. This prevents hallucinations. - Control: You define the rules. You can instruct the AI to focus on security, UI, or logic by changing the prompt. - Automation: If the AI finds issues, it marks the PR as “Request Changes.” If the code is clean, it simply leaves a summary comment. - Lightweight: It uses standard Python libraries like urllib. You do not need to manage heavy dependencies. How to set it up: 1. Create a.github/workflows/ ai-review.yml file in your repo. 2. Add your GEMINI_API_KEY to your GitHub repository secrets. 3. Paste the workflow configuration to handle the diff, the API call, and the comment posting. You get a self-hosted code guardrail that stays under your total control. Source: https://lnkd.in/gTx4TVXw Optional learning community: https://t.me/GyaanSetuAi 댓글을 보거나 남기려면 로그인
  • Most side projects die at version 1.0. Not because the idea was bad. Because version 1.0 only solves YOUR problem — and nobody else’s project looks exactly like yours. I’ve been building predeploy-check, a CLI that catches deployment failures before you push your code. The first version worked for my setup. But every project is different — some don’t need certain checks, some have extra env files to scan, some have paths that should be ignored entirely. So I added a config file. Now you can drop a predeploy.config.js in your project root and tell it exactly what to check, what to skip, and how to behave. Disable checks that don’t apply. Add custom env files. Ignore legacy folders. It reads your config, confirms it loaded, and runs accordingly. Small thing. But it’s the difference between a tool you try once and a tool you actually commit to your repo. The project now has 82 automated tests, three output modes (terminal, JSON, live PyPI verification), and a proper README that doesn’t assume you already know what it does. If you deploy to Render or Vercel and you’ve ever been surprised by a failed build that worked perfectly on your machine — this might save you the next one. npx predeploy-check GitHub: https://lnkd.in/d_ybUgF5 npm: https://lnkd.in/dPJ3RBb2 #machinelearning #nlp #genai #softwareengineering #opensource #buildinpublic #devtools #nodejs #python #startup #datascience #npm #dataanalytics #machinelearing #build 댓글을 보거나 남기려면 로그인
  • What does it take to build a fully featured ai agent like Claude Code or Codex? an agent that can use tool calling and work effectively in a given environment? (think: deep research, write code, write contracts, send emails, file taxes, query databases, train machine learning models, …) Turns out it takes about 9 lines of Python. Only standard library, no external dependencies. Why no dependencies? First of all: because they are not needed. But there are more benefits that come with avoiding external dependencies. Most coding harnesses come with dozens if not hundreds or thousands dependencies (libraries, frameworks, utilities, …) which create a huge supply chain attack surface. If you are building software powered by agent functionality; ideally you have a way to manage your supply chain risk. One way to do that is to start from a minimal base that comes with few or no dependencies. This agent is 9 lines of Python. They are a bit terse (some would say “golfed”). The idea is to be able to see all of it on one page, no fluff, no scrolling. if you expand them to be less golfed you get about 60 lines. You can read the whole code in a few minutes, you can ask your favorite agent to explain the code to you. The whole agent is small enough to comfortably fit in your favorite language model’s context window. If you’re curious about how the agent works, what it can do and not do: here is the ‘Show HN’ post on hacker news about it: https://lnkd.in/dQyQjKeQ 댓글 7 댓글을 보거나 남기려면 로그인
  • Every developer starts with a Speech-to-Text Playground. But the best developers know when it is time to move beyond it. Migrating to Python SDK v6 is the step that separates prototypes from production-grade solutions. Here is exactly what changes when you make the move: ✅ From UI to Code: Move from manual testing to full automation ✅ Better Performance: Faster and more reliable transcriptions at scale ✅ Production Ready: Built for scale, security and complete control ✅ Developer Friendly: Cleaner APIs, better docs and easier integration The Playground gives you: ✅ Simple audio input interface ✅ Quick configuration and results ✅ Great for testing and prototyping Python SDK v6 gives you: ✅ Full SpeechClient control in your own codebase ✅ Custom language configuration including en-US and 50 plus languages ✅ Direct audio file processing with a single transcribe call ✅ Production-ready, Scalable and Powerful output The code is clean. The setup is simple. The results are transformational. Stop prototyping. Start deploying. Read the complete developer guide here: https://lnkd.in/dJ3N8QEc Download VoxClone AI and start your free clone today: https://lnkd.in/g9jz593S Are you still using a Playground for production Speech-to-Text work? Share your thoughts below. hashtag#SpeechToText hashtag#PythonSDK hashtag#VoxCloneAI hashtag#DeveloperTools hashtag#VoiceAI hashtag#PythonDeveloper hashtag#AIAutomation hashtag#MachineLearning hashtag#APIIntegration hashtag#TechNews 댓글을 보거나 남기려면 로그인
  • AI Agents typically operate on a framework called ReAct (Reason + Act): Reason (Thought): The LLM analyzes the user’s request and decides what needs to be done. Act (Tool Use): The agent triggers an external tool. It might run a Python script, search the web, query an API, or write to a file. Observe: The agent looks at the output of the tool it just used. If the task isn’t finished, it loops back to the “Reason” step to decide what to do next. For example, if you ask an agent, “What is the current price of Apple stock, and if I bought 10 shares today, how much would that be in Egyptian Pounds?”, the agent will reason that it first needs to trigger a web search tool to find the stock price, then trigger a calculator tool to multiply by 10, then trigger a currency conversion tool to get EGP, and finally return the result to you. 댓글을 보거나 남기려면 로그인

팔로워 86,346명


  • Source: Unknown