RAGFlow v0.27.0 Released: Knowledge Compilation and Agentic RAG Upgrades

Vincent now builds Vincent. 🚀 With v0.7.0, the project reached an important milestone: all of Vincent’s own development now runs through Vincent. From GitHub issue → planning → implementation → verification → human approval → merge → release preparation. Along the way, v0.5–v0.7 added: ⚙️ Agent-authored workflows with declared and validated inputs 🔄 Follow-ups, repair agents and retry/backoff 🖥️ A much broader CLI and scriptable control plane 💰 Per-task cost limits 📋 Richer full-screen task workspaces with output and diffs 🔔 Status publishing and state-change notifications 🛠️ Backup, restore and improved diagnostics 🔓 And Vincent is MIT licensed again The goal remains the same: keep durable state, orchestration and verification in a local, vendor-independent layer while tools like Claude Code, Codex or Cursor handle inference. I wrote about what changed from v0.4.0 → v0.7.0 and why this milestone matters: https://lnkd.in/dS-Xhf6q #opensource #ai #softwaredevelopment #developerTools #aiagents #codingagents

𝗖𝗵𝗮𝗽𝘁𝗲𝗿 𝟲: 𝗖𝗮𝗻 𝗪𝗲 𝗜𝗺𝗽𝗿𝗼𝘃𝗲 𝘁𝗵𝗲 𝗥𝗲𝗾𝘂𝗲𝘀𝘁 𝗕𝗲𝗳𝗼𝗿𝗲 𝗜𝘁 𝗥𝗲𝗮𝗰𝗵𝗲𝘀 𝘁𝗵𝗲 𝗠𝗼𝗱𝗲𝗹? In the previous chapter, we discissed about routing and not every request deserves the most powerful model. But even after choosing the right model, are we sending it the best possible request? As developers, we've become surprisingly good at accepting our prompts exactly as we write them and assume the model will figure it out. But if the gateway already sits between the developer and the model, maybe it shouldn't just forward requests. It should improve them, Not by changing what the developer is asking but by making the request more efficient. For example: - Removing unnecessary context that doesn't contribute to the answer and preserving only the information that is actually relevant. - Adding system instructions that remain consistent across requests. - Standardizing prompts so different developers don't unknowingly ask the same question in completely different ways. None of these ideas make the model "smarter.” but they simply reduce unnecessary work before the expensive inference begins. And that's something I kept noticing while building this project. Many optimization discussions focus on choosing a cheaper model, but sometimes the bigger opportunity is sending a better request to whichever model we've already selected. This introduces another trade-off. If the gateway becomes too aggressive while modifying requests, it risks changing the user's original intent and If it becomes too conservative, the optimization barely matters. as per me, the architecture finds itself walking a very fine line. Not between fast and slow or between cheap and expensive, but between optimization and correctness. The more I build LLMGuardian, the more I realize the gateway isn't there to replace the developer. Its sole job is to quietly remove unnecessary work without changing the problem the developer is trying to solve. That's a much harder responsibility than simply forwarding an API request. The next challenge naturally follows from here. If the gateway is reading and processing every request before it reaches an external model, 𝘏𝘰𝘸 𝘥𝘰 𝘸𝘦 𝘮𝘢𝘬𝘦 𝘴𝘶𝘳𝘦 𝘴𝘦𝘯𝘴𝘪𝘵𝘪𝘷𝘦 𝘪𝘯𝘧𝘰𝘳𝘮𝘢𝘵𝘪𝘰𝘯 𝘯𝘦𝘷𝘦𝘳 𝘭𝘦𝘢𝘷𝘦𝘴 𝘰𝘶𝘳 𝘴𝘺𝘴𝘵𝘦𝘮 𝘶𝘯𝘪𝘯𝘵𝘦𝘯𝘵𝘪𝘰𝘯𝘢𝘭𝘭𝘺? That's the problem I'm exploring next. GitHub Repository: In the comments. #AIInfrastructure #LLM #BackendEngineering #SystemDesign #GenerativeAI

📚 Study Notes: DeepSeek Harness — how a production-grade AI agent framework is built Spent time this week going deep into DeepSeek Harness (dsh), an open-source, plugin-composed agent CLI. A few things stood out: 🧩 Everything is a plugin — the model adapter, tool registry, even the agent loop itself is swappable behind the Cordis framework's dependency-driven lifecycle. 🔁 The turn/step loop is the spine — every request, tool call, and result is a durable, replayable session event. "Model-visible" and "logged" are the same thing by design. 🌱 Subagents, two ways — spawn a fresh child agent, or fork a live one seeded from its parent's completed turns, with depth-limited recursion to keep delegation bounded. 🔍 Search without a search engine — no dedicated retrieval endpoint; web_search runs as a full model turn with a native server-side search tool, returning structured, citation-backed results instead of scraped prose. Reading real source alongside real session logs — not just docs — made the architecture click in a way slides never do. https://lnkd.in/gdJJikeF #opensource #ai #agentarchitecture #deepseek #softwareengineering Published by Claude Code, automatically.

Runbooks provide the ability to run ad-hoc and maintenance tasks. With Runbook Webhook Triggers, they can now be executed with a simple HTTP POST request. https://lnkd.in/gqECE7TP #Octopus #AI #DevOps

If an AI agent hallucinates in production today, fixing a single sentence in its system prompt usually takes a whole release cycle: open a PR, edit a string, wait on container builds, and redeploy the backend. That is 45 minutes of turnaround for a ten-word fix. While building PromptMatrix over the last six months, we tried decoupling prompts from application code entirely. We ran into three issues right away: 1. Latency: A 150ms HTTP round-trip on every agent step stalls synchronous swarms. Prompt serving has to run from an in-memory cache in under 5ms. 2. Schema breakages: Hot-patching prompts without automated checks breaks downstream JSON parsers. Eval gates in CI (pmx eval) are mandatory before promoting changes. 3. Rollback speed: When a new prompt misbehaves, git reverts are too slow. You need instant, immutable version rollbacks. We built PromptMatrix to solve this: an open-source behavior registry and control plane for AI swarms (LangGraph, CrewAI, and OpenClaw) that lets you hot-patch prompts with sub-5ms serving, automated eval gates, and zero downtime. You can try the open-source engine or check out the cloud version here: 👉 https://lnkd.in/dWn4jmis If your database has migrations and your API has version control, your agent system prompts shouldn't live as hardcoded string literals inside your app repo. How does your team handle prompt hot-fixes in production right now? #AIEngineering #LLMOps #LangGraph #MultiAgentSystems #SoftwareEngineering #OpenSource

Your AI model writes code. But who gives it tools, memory, and a team? 🧠⚡ Meet Ruflo — The multi-agent orchestration platform for Claude Code. Formerly Claude Flow. Now production-ready v3.5.0 🚀 Agent = Model + Harness The model writes. The harness makes it actually work. Ruflo is that harness. What Ruflo adds to Claude Code in 1 command: npx ruflo init 1. 🐝 Swarm Coordination 60+ specialized agents that self-organize into teams Choose: hierarchical, mesh, or adaptive topology 2. 🧠 Self-Learning Memory Agents remember across sessions with AgentDB + HNSW vector search 150x-12,500x faster than brute force Learns from every success and failure 3. 🌐 Federation Agents on different machines collaborate securely without leaking data 4. 🛡️ Enterprise Security AIDefence for PII detection + prompt injection blocking Witness verification with signed manifests 5. 🛠️ 314 MCP Tools Memory, coordination, neural routing, embeddings, security Works with Claude Code + Codex out of the box How it works: User → Ruflo CLI/MCP → Router → Swarm → Agents → Memory → LLM Providers ↓ Learning Loop After `init`, just use Claude Code normally. Hooks automatically route tasks and coordinate agents in the background. v3.5.0 Production Release includes: 1. Deep agentic-flow integration + 3-tier model routing. Save up to 75% on API costs 2. AgentDB v3 with 8 new controllers for memory and routing 3. Zero production vulnerabilities Built by rUv as part of the open-source AI systems stack: RuView, Ruflo, MetaHarness, RuVector Get started: npm: npx ruflo@latest GitHub: https://lnkd.in/dXbtHZUS Have you tried multi-agent swarms for coding yet? What’s the biggest bottleneck in your AI agent workflows right now? Comment below 👇 #Ruflo #AI #MultiAgent #ClaudeCode #AgenticAI #OpenSource #Rust #MCP #LLM #Developers #AIOrchestration #AutonomousAgents #Tech2026 #SoftwareEngineering #BuildInPublic

𝗛𝗼𝘄 𝗺𝗮𝗻𝘆 𝘁𝗶𝗺𝗲𝘀 𝗱𝗼𝗲𝘀 𝘆𝗼𝘂𝗿 𝗮𝗴𝗲𝗻𝘁 𝗵𝗶𝘁 𝘁𝗵𝗲 𝗟𝗟𝗠 𝘁𝗼 𝗮𝗻𝘀𝘄𝗲𝗿 𝗼𝗻𝗲 𝗾𝘂𝗲𝘀𝘁𝗶𝗼𝗻? Most people say one. It's two! And most architecture diagrams only show one. Here is what actually happens when a user asks "check discount for order #104": 𝗟𝗟𝗠 𝗖𝗮𝗹𝗹 𝟭: the model reads the question and picks a tool. It returns get_discount(id=104). That is not an answer. It is a decision. Your code runs the function. Gets back {"discount": 0.15}. 𝗟𝗟𝗠 𝗖𝗮𝗹𝗹 𝟮: that raw JSON goes back to the model along with the original question. Now it writes "Your order qualifies for a 15% discount." Two calls. Every single tool use. 𝗦𝗼 𝘄𝗵𝗮𝘁 𝗶𝘀 𝘁𝗵𝗲 𝗠𝗖𝗣 𝗱𝗲𝗯𝗮𝘁𝗲 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗮𝗯𝗼𝘂𝘁? Not speed. Not local versus external. Both flows are identical. Same two LLM calls, same raw JSON, same synthesis step. One thing changes: where the tool lives. 𝗡𝗮𝘁𝗶𝘃𝗲: the function sits inside your agent's codebase. Private. Only this app can call it. 𝗠𝗖𝗣: the tool sits behind a server speaking a standard protocol. Any agent can plug in. That distinction gets blurred a lot, so to be clear: a native function can absolutely call the GitHub API, and an MCP server can absolutely return data from local memory. Local versus external was never the axis. Private versus shared is. 𝗧𝗵𝗲 𝗿𝘂𝗹𝗲 𝗜 𝘂𝘀𝗲 𝗡𝗮𝘁𝗶𝘃𝗲 when the tool belongs to one app and you want zero protocol layer between you and your own code. 𝗠𝗖𝗣 when two or more independent teams need the exact same tool, and you would rather not maintain three copies of the same integration. It is a coupling decision, not a performance one. Are you exposing tools through MCP yet, or still wiring them natively? #AI #MCP #AIAgents #LLM #AIEngineering #SystemDesign

Building an AI prototype over the weekend takes 48 hours. Keeping it alive in production past Day 30 is where the real bill comes due. Every non-technical founder I speak with has the same story right now: 1. They used Cursor, Lovable, or an agent builder to spin up a working demo. 2. It looked magical in testing. 3. They gave it to their first 50 users. Within 72 hours, the app started failing: - API bills spiked out of nowhere - Agents got stuck in infinite retry loops - Responses took 9 seconds to load - Edge-case queries produced bizarre hallucinations If you are moving from weekend prototype to production software, run this 4-part audit before you onboard more users. ### 1. Hard Retry Ceilings When an LLM endpoint errors or times out, naive code retries automatically. If three concurrent users trigger an unhandled edge case, your app can fire 500 API calls in 60 seconds. Set a hard ceiling of 2 retries per request. After that, log the failure and return a graceful message. ### 2. Semantic Caching If 100 users ask the same onboarding question or request the same summary, you should not pay OpenAI or Anthropic 100 times. Set up a semantic cache (like Redis with vector search). If a new query matches a previous one with 95%+ semantic similarity, serve the cached answer in 10ms for $0.00. ### 3. Deterministic Fallbacks Never let a user stare at a frozen loading spinner when an external model experiences latency spikes. If latency exceeds 2.5 seconds on non-reasoning tasks, fail over to a smaller, faster model or a structured rule-based response immediately. ### 4. Schema Validation on Every Output Never pipe raw LLM text directly into your database or UI. Use Pydantic or Zod schemas to enforce strict JSON output. If the model drops a required key or returns malformed text, catch it at the API layer before the user ever sees a broken screen. Building a demo proves the idea works. Engineering the guardrails is what makes it a real business. Save this checklist to review with your technical team before your next sprint.

I’ve just published Part 3 of my MCP series: Build a Local AI Agent with Ollama and TypeScript. This time, I moved beyond the architecture diagram and built the complete flow: • A local Qwen model running through Ollama • An MCP server with prompts, resources, and tools • A bounded TypeScript tool loop • Human approval before consequential writes • Offer-version and idempotency protection • A simulated flight-booking workflow The biggest lesson was that connecting a model to tools is the easy part. The real engineering work belongs in the host: controlling capabilities, validating requests, freezing approved payloads, handling retries safely, and keeping the model inside clear boundaries. How are you handling tool approval and write safety in your AI agents? #MCP #AIAgents #Ollama #TypeScript #LocalLLM