PipesHub

Conecta el conocimiento corporativo de tu organización con tus agentes con PipesHub. PipesHub es una capa de contexto que se puede conectar a múltiples sistemas, tanto en tiempo real como de manera calendarizada, para darle a tus sistemas agénticos mayor información para las respuestas. Además, PipesHub respeta los permisos de acceso, por lo que solo realiza búsquedas en los sistemas a los cuales el usuario ya tiene acceso, también genera jn grafo de conocimiento para entender las relaciones entre documentos, genera citas en cada respuesta hacia los documentos originales, entre varias funciones más. Lo mejor es que permite además crear agentes dentro de la misma plataforma y usando cualquier modelo LLM de preferencia, incluyendo modelos dentro e la misma infraestructura para evitar exponer información sensible. PipesHub es totalmente Open source y además extensible. Enlace: https://lnkd.in/dgC3wcFh --- Connect your organization's corporate knowledge with your agents using PipesHub. PipesHub is a context layer that can connect to multiple systems, both in real time and on a scheduled basis, to provide your agent systems with more information for their responses. Furthermore, PipesHub respects access permissions, so it only searches systems to which the user already has access. It also generates a knowledge graph to understand the relationships between documents, generates citations in each response to the original documents, among several other features. Best of all, it also allows you to create agents within the same platform and using any preferred LLM model, including models within the same infrastructure to avoid exposing sensitive information. PipesHub is completely open source and also extensible. Link: https://lnkd.in/dgC3wcFh

Whenever you ship a product update, parts of your documentation quietly break. A team we spoke with tried using an internal AI search tool to automatically find every outdated doc after each release. The suggestions were consistently terrible. The reason was surprisingly simple: An out-of-date doc doesn’t mention the new feature’s name—that’s literally why it’s wrong. Because it shares no context with the new update, standard AI search ranks it at the very bottom. They assumed their AI search model was broken. But the real problem was that the evidence lived in Jira tickets and Git diffs, not the docs index. We solved this with PipesHub by connecting their tools into a single context layer—allowing the system to inspect what actually changed and search for the replaced behavior instead. Why standard search struggles with documentation drift and how to solve it: https://lnkd.in/g_ST3hNc #SystemDesign #RAG #AI #DevOps

Y Combinator open-sourced QM to give every employee an AI agent. The problem? Out of the box, an agent doesn't have company context. If you ask it: "What did we agree with Acme on renewal?", it either hallucinates or says it doesn't have access. Worse: if you try connecting Drive, Slack, and Jira directly, you run into the multi-tenant permission nightmare. An agent with global read access is just a security leak with a chat interface. We built PipesHub to solve the context layer. Here is what changes when you connect PipesHub to YC QM: 1. Single Index: Drive, Slack, Gmail, Jira, and Confluence indexed together. 2. Strict RBAC: Queries run using the user’s personal keychain token. If someone can't open the Google Doc, the agent won't read it to them. 3. Verified Citations: Every claim links directly to the source ticket or thread. We put together a step-by-step guide to get it running in 4 steps using @pipeshub-ai/mcp on Fly Sprites. Full tutorial and walkthrough: https://lnkd.in/g_8pcqTQ #AI #YCombinator #OpenSource #DevOps #EnterpriseAI #SoftwareEngineering

As frontier models become exponentially more capable, the number one security concern I'm hearing from engineering leaders isn't prompt injection. It's Shadow AI. If your organization is moving too slowly, your employees aren't waiting. They are pasting proprietary code into public Claude windows and dropping customer transcripts into ChatGPT just to get their jobs done faster. When IT finally panic-ships a sanctioned, internal AI wrapper, adoption usually flatlines. Why? Because it lacks context. A "safe" internal AI that can't read your company's Jira, Slack, or Salesforce is useless compared to the public tools employees already use. To beat Shadow AI, you have to give employees a tool that actually understands their cross-tool workflows. But wiring an LLM directly to your SaaS ecosystem is a massive access-control risk. This is exactly what we are solving at PipesHub. You cannot rely on an LLM to guess security rules at runtime. You need a deterministic AI context layer. By pre-computing the enterprise graph—resolving cross-tool identities and enforcing zero-trust permissions upstream—we guarantee the AI only retrieves data that the specific user is authorized to see. Security gets deterministic compliance. Employees get an internal AI powerful enough to replace their shadow tools. How is your team balancing the demand for AI productivity with the risk of data leaks? #EnterpriseAI #ShadowIT #CyberSecurity #LLM #PipesHub

Your AI agents shouldn’t need a custom data pipeline for every company tool. PipesHub is an open-source, self-hostable context layer for enterprise search, RAG apps, AI agents, MCP servers, and agentic workflows. It helps you connect company knowledge in one place while preserving source-level permissions and returning answers with precise citations to the original documents. Key features: • 50+ enterprise connectors – index data in real time or on a schedule • Permission-aware search – users only see content they’re authorized to access • Explainable answers – responses include precise block citations back to source documents • Graph-backed retrieval – capture relationships across company data with knowledge graphs • Developer-ready integrations – extend it through APIs, Python/TypeScript/Go SDKs, MCP tools, and custom connectors It’s open-source (Apache License 2.0). 🔗 GitHub: https://lnkd.in/dz6nr3t3 ⸻ ♻️ Share this with your network if you found it useful or insightful. ✉️ If you’re into AI, ML, agents, and building real systems, join my newsletter (it’s free): dankornas.substack.com

PipesHub is #8 trending on GitHub this week. We're the open-source context layer for enterprise AI. The infrastructure that unifies your business data so you get explainable enterprise search and agentic workflow automation. And we just opened an AI Engineer Intern role. You'd sit with the founding team and work on agent architecture, RAG pipelines that hold up under real load, and enterprise AI infrastructure. From day one, on code that ships to users. We're looking for someone with strong Python skills, genuine curiosity about how AI systems work under the hood, and something you've built that you can walk us through. College, degree, or CGPA isn't the filter. What you've built is. If that sounds like you, we'd love to hear from you. And if you've been following what we're building: Star the repo. It helps more developers discover PipesHub. Apply for the internship. Both links are in the comment. 👇 We're at #8. Let's see how far we can take it. #Hiring #Internship #AIEngineer #OpenSource #GitHub

We might be focusing on the wrong metric in the enterprise AI debate. Much of the timeline is arguing over "token budgets"—whether an agent should use 10k or 100k tokens per task. But token burn is usually just a symptom. The deeper issue is what happens before the model starts reasoning: how we handle context. Right now, many enterprise deployments rely on live "exploratory retrieval." An agent connects to a dozen apps via MCP, receives a prompt, and trial-and-errors its way through enterprise data: 1. Querying Jira, getting partial context, and retrying. 2. Searching Slack threads and risking hallucinations. 3. Resolving permissions on the fly—turning a hard security boundary into a probabilistic guess. That multi-turn loop becomes a recurring tax on latency, cost, and reliability. ### "But how do you pre-compute context for unpredictable queries?" This is the most common pushback. Real enterprise work is unpredictable, and you can't anticipate every prompt. The key distinction: you don't pre-compute the destination—you pre-compute the map. Think of Google Maps. It doesn’t pre-calculate every drive you will ever take. But it does map the roads, link intersections, and flag private, gated streets ahead of time. When you enter an ad-hoc destination, it calculates the optimal route in milliseconds. Relying purely on live tool-calling is like dropping an agent in a city with no map—forcing it to stop at every intersection to ask external APIs for directions until it finds the answer. ### The Division of Labor To make agents reliable, we need a clear split: * Pre-Computed Upstream: Cross-tool identity mapping (Jira user = Slack handle = GitHub ID), relationship linking (Zendesk ticket → Slack debug thread → GitHub PR), and zero-trust permission boundaries. * Handled at Runtime: When an ad-hoc query arrives, the agent still fetches data in real time—but instead of guessing across APIs, it traverses a pre-structured graph to pull the exact, permission-verified context in one step. ### The Long-Term Moat Federated tool-calling and MCP serve a purpose for simple, dynamic lookups. But for deep reasoning across tools, leaving identity, security, and relationship mapping to a live LLM reasoning loop introduces too much friction. The long-term advantage won't just be who has the biggest context window, but who builds permission-aware context layers upstream. Let frontier models spend their compute doing what they do best: solving complex problems, not rediscovering enterprise structure on every turn. How is your team balancing live tool-calling with upstream indexing? Are you seeing a shift toward structured context layers? #EnterpriseAI #AIArchitecture #DataEngineering #LLM #FutureOfWork

Imagine you ask your AI agent a question about a specific table in a 50-page document. The system grabs a few relevant sentences, but misses the headers and the crucial context right beneath them. To fix this, you do what most teams do: you configure your RAG pipeline to just dump the entire 50-page parent document into the LLM. It gets the job done, but as a result, your latency spikes and your token bill absolutely explodes. There is a better way to solve this than just brute-forcing it with more tokens. Tushar Sharma on our engineering team has been writing a really good series on how we solve this at the architecture level here at PipesHub. (Check out the diagram below for a look at the actual decision loop we built). He breaks down the exact mechanics of what we are doing here: Part 1: Why standard "flat chunking" breaks down in real-world use cases: https://lnkd.in/gQt2jfZD Part 2: How we built a 4-level hierarchy to preserve the actual structure of a document: https://lnkd.in/gbTTeyp8 Part 3 (just published): How our agents use a 3-tool decision loop to fetch larger chunks only when they actually need them: https://lnkd.in/gjqEauD4 The end result for the business is straightforward—you get accurate, contextual answers without the massive token bloat. Tushar is one of those rare engineers who not only ships complex infrastructure but can explain the "why" behind it perfectly. If you are building or scaling enterprise AI right now, do yourself a favor and read through his breakdowns. It will save you a lot of time, latency, and token costs down the line.