Eliminate Tool Schema Bloat with codemode-lite

Why does every AI review start from zero? Why burn thousands of tokens re-discovering the same call chains, the same module structure, the same dependency graph every single time? The idea isn't new. code-review-graph already solved this in Python and it works. I've been using it. But Python has a ceiling: single-threaded parsing, GIL contention on large repos, and startup overhead that adds up when you're calling it 50 times a day through MCP. So I rewrote the entire thing in Go. Not a wrapper. Not bindings. A ground-up port designed around goroutines, channels, and SQLite WAL mode. Result: code-review-graph-go Same concept. Fundamentally different performance characteristics. Here's what changed in the Go version: → Goroutine-parallel parsing: Tree-sitter across 17 languages, N=NumCPU workers. 1,800 nodes and 10,000+ edges in ~1.5 seconds. The Python version does this sequentially. → SQLite with WAL mode concurrent readers, mutex-serialised writer. Incremental updates only re-parse what git diff says changed, then expand to dependents via multi-hop BFS. → Hybrid search engine: FTS5 BM25 + vector embeddings merged via Reciprocal Rank Fusion. "UserService" auto-boosts Class results. "get_user" auto-boosts Functions. Context-file boosting for what you're actively editing. The Python version has this too, the Go version adds the RRF merge with zero-allocation hot path. → 19 MCP tools that drop into Claude Code, Cursor, Windsurf, Zed, Continue, or OpenCode with a single install command. Full JSON-RPC 2.0 over stdio. → Execution flow tracing that walks every code path from entry point to leaf call, scored by criticality (file spread, security sensitivity, test coverage gaps). → Refactoring engine previews renames across every call site, detects dead code, suggests moves based on community structure, and applies changes with path-traversal safety checks. → Auto-generated wiki from your codebase's community structure. Markdown pages with member tables, flow summaries, and cross-community dependencies. → Context-aware hints the MCP server tracks your session, infers whether you're reviewing/debugging/refactoring, and appends next-step suggestions to every tool response. All of it runs locally. No API keys. No cloud. Just a single Go binary + SQLite. Full credit to the original Python project by Tirth Kanani for the architecture and the idea. Today I'm open-sourcing the whole thing. But here's what I really want: If you work on a codebase with 500+ files, try it. Run build, then search, then detect-changes. See if the graph catches relationships you didn't know existed. Then tell me what's broken. Want to compare it against the Python version on your repo? I'd genuinely love to see those benchmarks. This is better with a community. GitHub: https://lnkd.in/gSjZP3ay Drop a star if this resonates. PRs are very welcome. #opensource #golang #python #ai #codereview #mcp #llm #developer #tooling #treesitter #sqlite #performance

What if your code could think? That's LangChain. LangChain is a framework that lets you build apps powered by LLMs (like GPT or Claude) - with memory, tools, and logic. Here's how simple it is to build a chatbot with memory in Python: from langchain_openai import ChatOpenAI from langchain.memory import ConversationBufferMemory from langchain.chains import ConversationChain llm = ChatOpenAI(model="gpt-4") memory = ConversationBufferMemory() chain = ConversationChain(llm=llm, memory=memory) chain.predict(input="My name is Virat") chain.predict(input="What's my name?") # → "Your name is Virat." Without memory → every message is a fresh conversation. With memory → the model remembers context across turns. LangChain also lets you: 🔹 Connect LLMs to your own documents (RAG) 🔹 Give the model tools — search, calculator, APIs 🔹 Build multi-step AI agents that reason and act 🔹 Chain prompts together for complex workflows #LangChain #Python #LLM #MachineLearning #BackendDevelopment #LearningInPublic #Java #SpringBoot #AI

A supply chain attack hit a Python package with ~3 million daily downloads. Malicious code executed automatically on every Python process startup for roughly 40 minutes, enough time to harvest credentials and install a persistent backdoor. That package was LiteLLM, one of the most widely used AI gateway libraries in production environments. And the attack didn't even come through LiteLLM's own code; it came through a compromised GitHub Action in their CI/CD pipeline. The deeper lesson here isn't specific to LiteLLM. It's about how engineering teams think (or don't think) about AI gateways as infrastructure. A proxy that sees your LLM API keys, your prompts, and sits in the request path between your applications and your model providers isn't a dev tool. It's critical infrastructure. We wrote a breakdown of what happened, what the migration path looks like, and what questions to ask of any AI gateway you're evaluating. Link in comments.

I’ve been working on an open-source Python library for building AI agents. It’s called Dendrux. The idea is that agent runtimes should handle more than just calling an LLM and tools. In production, you usually need persistence, crash recovery, human approvals, budgets, and guardrails. Dendrux brings it into the runtime.  It handles:  1. Tool deny policies and human approval with pause/resume  2. PII redaction at the LLM boundary, so the model sees placeholders while tools receive real values  3. Advisory token budgets with threshold warnings  4. Crash recovery with stale-run sweeping  5. Client-tool bridging for browsers and spreadsheets It’s still early, currently v0.1.0a5, but the foundation is in place. Feedback, issues, and design critiques are welcome. GitHub: https://lnkd.in/gYbhpcdM

At ECIR 2026, we presented #OmniRec, a new open-source Python library for unified RecSys Experiments with popular libraries like #Lenskit, #RecBole, #RecPack, and #Elliot. Proudly hosted by Recommender-Systems.com (RS_c): https://lnkd.in/eSSmvUEb, joint work of Lukas Wegmeth, Moritz Baumgart, Philipp Meister, Bela Gipp, Joeran Beel. OmniRec acts as a central hub for the entire #recsys experimentation pipeline, from loading data to final evaluation. Its modular architecture is designed for transparency and ease of use. If offers: -- Access to 230+ Datasets: The library provides standardized, registered access to a vast library of datasets through a single interface. -- Write Once, Run Anywhere: Users define their preprocessing pipeline, including subsampling, filtering, and splitting strategies, just once. This pipeline then executes consistently across multiple integrated frameworks. -- Seamless Integration: The initial release features custom adapters for leading frameworks: RecPack, RecBole, Lenskit, and Elliot. -- No More Dependency Hell: OmniRec automatically manages isolated virtual environments for each library using the uv tool, preventing version conflicts between different research frameworks. -- Standardized Evaluation: A centralized Evaluator module ensures that metrics like nDCG, Recall, and RMSE are computed identically, regardless of which underlying framework trained the model

Python is too slow for the backend. 🥱 This was a valid take in 2023. In 2026? It’s a misunderstanding of how the Agentic Economy actually works. Despite the rise of high-performance languages, Python remains the undisputed king of the backend for AI-native systems. If you want to know why the world’s most advanced Sovereign AI architectures are still built on Python, here are the three non-negotiable reasons: 🚀 1. The "No-GIL" Revolution With the final removal of the Global Interpreter Lock (GIL), Python finally unlocked true multi-core concurrency. We can now run complex Agentic Orchestration and heavy data processing in a single process without the "performance tax" we used to pay. It’s no longer just a "scripting language"; it’s a high-velocity engine. 🧠 2. The "Gravity" of the Ecosystem Every breakthrough from Llama 4 to the latest MCP (Model Context Protocol) servers drops in Python first. When you’re building in a field that moves this fast, "Developer Velocity" is more important than raw execution speed. In the time it takes to write a memory-safe wrapper in another language, a Python dev has already shipped a self-correcting agent to production. 🔗 3. The Ultimate "Glue" for Hybrid Systems Modern backends aren't monolithic. We use Rust for the heavy math and C++ for the kernel, but Python is the connective tissue. It’s the language of LangGraph, PyTorch, and FastAPI. It allows us to orchestrate a "Polyglot Architecture" where we get 100% of the performance with 0% of the boilerplate. The 2026 Reality: We don't use Python because it’s the fastest. We use it because it’s the smartest. It allows us to spend less time fighting the compiler and more time architecting the intelligence. Are you still optimizing for nanoseconds, or are you optimizing for orchestration? Let’s talk about the 2026 stack below. 👇 #Python #BackendEngineering #AgenticAI #SoftwareArchitecture #2026TechTrends #MLOps #SystemDesign #DeveloperVelocity

 **𝗪𝗵𝘆 𝗣𝘆𝘁𝗵𝗼𝗻 𝗜𝘀 𝗣𝗼𝗽𝘂𝗹𝗮𝗿 𝗶𝗻 𝗕𝗮𝗰𝗸𝗲𝗻𝗱 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗺𝗲𝗻𝘁** When it comes to backend development… Python is always in the conversation 👇 𝗕𝘂𝘁 𝘄𝗵𝘆 𝗶𝘀 𝗶𝘁 𝘀𝗼 𝗽𝗼𝗽𝘂𝗹𝗮𝗿? 💡 👉 Because Python focuses on simplicity *without losing power.* 💻 Here’s what makes Python stand out: ✔ Clean & readable syntax 👉 Easy to learn, easy to maintain ✔ Rapid development 👉 Build APIs and systems faster ✔ Powerful frameworks 👉 Django, Flask, FastAPI ✔ Huge ecosystem 👉 Libraries for almost everything ✔ Scalability 👉 Used by startups & big tech companies 🔥 The real advantage? 👉 You spend less time fighting syntax… 👉 And more time solving real problems 📌 𝗧𝗵𝗮𝘁’𝘀 𝘄𝗵𝘆 𝗣𝘆𝘁𝗵𝗼𝗻 𝗶𝘀 𝘂𝘀𝗲𝗱 𝗳𝗼𝗿: ➡ Web backend (APIs & services) ➡ AI & Machine Learning ➡ Data processing ➡ Automation scripts 💡 Whether you're building a startup or scaling a system — Python gives you speed + flexibility. Because in modern development — #Python #BackendDevelopment #WebDevelopment #Django #Flask #FastAPI #FullStackDeveloper #SoftwareEngineering #CodingTips #DeveloperLife #TechStack #LearnToCode

Just shipped codectx v0.3.0!! For context — codectx is a CLI tool that compiles your codebase into structured context for LLMs. Instead of dumping raw source, it uses AST parsing and dependency graphs to figure out what actually matters and what doesn't. Benchmarks show 55–92% token reduction vs naive approaches on real-world Python repos. v0.3.0 is the biggest update since the initial release. Here's what changed: Embedding cache — codectx now stores embeddings in LanceDB and only re-processes files that have actually changed. If you're running it repeatedly on a large codebase, subsequent runs are noticeably faster. Watch mode — codectx watch . keeps context up to date as you work. Changes are batched over a debounce window so it's not rebuilding on every save. JSON output — --format json for pipelines, tooling, or anything that needs to consume the output programmatically instead of reading a markdown file. LLM summaries — --llm with OpenAI, Anthropic, and Ollama support. Swaps out the default AST-generated summaries with model-generated ones for your most critical files. Falls back gracefully if the provider call fails. Go support — the import resolver now parses go.mod to correctly strip module prefixes and resolve repo-relative paths. The old behavior was just broken for most Go projects. Also shipped in this release: symbol cross-referencing across files, constants extraction in structured summaries, and automatic demotion of config files (pyproject.toml, package.json, etc.) out of the core context tiers. If you've used it before, pip install --upgrade codectx gets you everything. GitHub: https://lnkd.in/gVzysfEw Docs: codectx.granth.tech

Built something exciting: CodeMailer AI – turning emails into AI-powered code reviews! Ever wished your inbox could review code for you? I built CodeMailer AI, an end-to-end Python automation tool that transforms Gmail into a smart code reviewer. 💡 What it does: Detects unread emails with Python attachments Analyzes code using advanced AI models (via OpenRouter) Generates structured insights—bugs, logic, execution flow & more Creates a clean, syntax-highlighted HTML report Automatically replies back to the sender with the review ✨ Key highlights: Seamless Gmail OAuth integration Deep AI-powered code analysis with inline comments Beautiful dark-mode HTML reports with Pygments styling Fully automated pipeline (read → analyze → generate → reply) Smart fallback to local files when inbox is empty ⚙️ Built using: Python, Gmail API, OpenRouter (Gemini 2.0 Flash), Jinja2, Pygments This project was a great hands-on experience in combining automation + AI + real-world workflows to build something practical and scalable. Would love your feedback! 🙌 #AI #Python #Automation #MachineLearning #Developers #Projects #OpenSource #BuildInPublic #Hack2Skill GitHub Project Link: https://lnkd.in/gYsGvBJw

Shipped: Python SDK for tag-graph agent memory. For a year I've been chasing one problem — how do you give an LLM agent memory that's bounded, predictable, and doesn't blow your token bill? Vector DBs → fuzzy, impossible to budget. Raw history → 5-turn context overflow. Summarize-and-re-inject → silently drops facts the agent needs three turns later. So we built MME — a bounded tag-graph memory engine. Every memory carries tags, retrieval starts from the current scope, propagates to neighbors with bounded fanout, ranks by graph proximity. Deterministic, token-budgeted, sub-50ms at 100k items. Today the Python SDK is live: → pip install railtech-mme → Native LangChain + LangGraph tool integrations → Online learning via feedback loops → Open source Wrote up the full design rationale, tradeoffs vs. vector search, and the SDK surface area here: https://lnkd.in/eNR5n_iq Honest beat — this is launch day. If you're building LLM agents in Python and "my agent doesn't remember things well" feels familiar, I'd love to hear what's clunky about the API. #AI #Python #LangChain #LLM #AgentMemory #BuildInPublic #OpenSource