AI Makerspace

What happens when 70 AI practioners spend 10 weeks mastering advanced RAG and agentic systems? You get Cohort 8. 𝐓𝐡𝐞𝐢𝐫 𝐀𝐈 𝐄𝐧𝐠𝐢𝐧𝐞𝐞𝐫 𝐁𝐨𝐨𝐭𝐜𝐚𝐦𝐩 𝐃𝐞𝐦𝐨 𝐃𝐚𝐲 𝐢𝐬 𝐣𝐮𝐬𝐭 𝐨𝐧𝐞 𝐰𝐞𝐞𝐤 𝐚𝐰𝐚𝐲! This cohort built sophisticated, multi-agent solutions for real-world problems using LangGraph, Ragas, and advanced retrieval. We saw an explosion of innovation across categories like 𝐃𝐞𝐯𝐞𝐥𝐨𝐩𝐞𝐫 𝐓𝐨𝐨𝐥𝐬, 𝐋𝐞𝐠𝐚𝐥 & 𝐂𝐨𝐦𝐩𝐥𝐢𝐚𝐧𝐜𝐞, 𝐇𝐞𝐚𝐥𝐭𝐡 & 𝐖𝐞𝐥𝐥𝐧𝐞𝐬𝐬, 𝐌𝐚𝐫𝐤𝐞𝐭𝐢𝐧𝐠 & 𝐂𝐨𝐦𝐦𝐮𝐧𝐢𝐜𝐚𝐭𝐢𝐨𝐧 and 𝐄𝐝𝐮𝐜𝐚𝐭𝐢𝐨𝐧. Over 40 projects were submitted. We're showcasing the top projects, and the quality is outstanding. You'll see projects like: 🚦 𝐓𝐑𝐀𝐅𝐅𝐈𝐗 by Betsy Berenback-Gold: An AI storytelling assistant that integrates structured traffic data with unstructured news and weather sources to create narrative insights for transportation analysts 📕 𝐋𝐞𝐠𝐚𝐥-𝐎𝐒 by Raphael Blankson: A 5-agent system that automates M&A legal due-diligence by analyzing large documents. 🏗️ 𝐁𝐮𝐢𝐥𝐝𝐎𝐩𝐭𝐢𝐦𝐚 by Will Holt: AI-powered real estate development intelligence that optimizes build decisions for maximum ROI 👷♀️ 𝐂𝐨𝐧𝐬𝐭𝐫𝐮𝐜𝐭𝐢𝐨𝐧-𝐬𝐩𝐞𝐜-𝐚𝐬𝐬𝐢𝐬𝐭𝐚𝐧𝐭 by Rafael Torres Coelho Soares: An agentic AI system with OCR designed to help Construction Architects review construction documents and identify inconsistencies between original specifications/drawings and Contractor Submittals. 📹 𝐀𝐠𝐞𝐧𝐭𝐢𝐜 𝐒𝐞𝐧𝐭𝐢𝐦𝐞𝐧𝐭 𝐀𝐧𝐚𝐥𝐲𝐳𝐞𝐫 by Inés Arana Bachelis: A multi-agent conversational system featuring "Research" and "Analysis" teams orchestrated with LangGraph that helps content creators understand sentiment and topics in YouTube videos. 𝐅𝐨𝐫 𝐭𝐞𝐜𝐡 𝐥𝐞𝐚𝐝𝐬, 𝐡𝐢𝐫𝐢𝐧𝐠 𝐦𝐚𝐧𝐚𝐠𝐞𝐫𝐬, 𝐚𝐧𝐝 𝐀𝐈 𝐞𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐬—𝐭𝐡𝐢𝐬 𝐢𝐬 𝐰𝐡𝐞𝐫𝐞 𝐲𝐨𝐮'𝐥𝐥 𝐬𝐞𝐞 𝐰𝐡𝐚𝐭 𝐲𝐨𝐮 𝐜𝐚𝐧 𝐛𝐮𝐢𝐥𝐝 𝐰𝐢𝐭𝐡 𝐀𝐈 𝐭𝐨𝐝𝐚𝐲. 🏗️ 🚢 🚀 Join us live to see the top demos. Event Link: https://lnkd.in/gjszCU9Z #langgraph #multiagent #rag #retrieval #evaluation #innovation #sentimentanalysis #construction #traffic #analyst #ai #sentimentanalysis

📐👷🏻♀️ 🚀 I'm excited to announce the launch of my latest project, an AI-powered assistant for reviewing construction specifications and submittals. For the past few weeks, I have been part of the AI Engineer Bootcamp - Cohort 08 at AI Makerspace, and I have been working on this project as my final certification challenge. In this project, I applied all the knowledge I had acquired during the boot camp to build an end-to-end Agentic RAG Prototype. This is an agentic AI system designed to assist Construction Architects and Engineers in reviewing construction documents and identifying inconsistencies between the original specifications/drawings and contractor submittal documents. The Problem 👨🏻💻 Construction Documents review is a tedious and time-consuming task that can take many hours or days to complete, depending on the complexity of the project and the number of documents involved. Architects spend a lot of time in front of their computer screens comparing complex documents full of heavy technical terminology and CAD drawings in search of inconsistencies and discrepancies. The Solution 🤖 Enters the Construction Spec Assistant! 🤖 An AI-powered assistant for reviewing construction specifications and submittals.  The system transforms unstructured construction documents into searchable, comparable data, automating the tedious process of submittal review for Architects. Key Features: - Document Processing: PDF parsing using Docling with OCR support - Fact Extraction: LLM-based extraction of structured facts from specifications - Vector Search: Hybrid dense + sparse (BM25) search with in-memory Qdrant - Agentic Workflows: LangGraph-powered multi-step comparison workflows - Multi-LLM Support: OpenAI, Anthropic, and Ollama integration Architecture: - Backend: Python FastAPI with automatic OpenAPI docs - Frontend: React + TypeScript + Vite with Tailwind UI - Storage: MongoDB for facts/metadata, Qdrant for vectors - Processing: Docling for PDF extraction - AI Workflows: LangChain/LangGraph - Observability: LangSmith for tracing and monitoring Workflow 1. Upload construction PDFs (specs, drawings, submittals) 2. Parse and extract structured "facts" with normalized units 3. Index content for hybrid search 4. AI agents compare specifications against submittals 5. Generate structured findings with citations 6. Human review with accept/reject feedback </> Check out the project at https://lnkd.in/gmxkpidJ 🎥 Check out a 5-minute demo at https://lnkd.in/gMPeNhBz Many thanks to Laura Funderburk for all the guidance and patience during this project. #Construction #Architecture #AI #Automation

🤖 𝗕𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗔𝗴𝗲𝗻𝘁-𝘁𝗼-𝗔𝗴𝗲𝗻𝘁 𝗖𝗼𝗺𝗺𝘂𝗻𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝘄𝗶𝘁𝗵 𝘁𝗵𝗲 𝗔𝟮𝗔 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹 Completed a deep dive into the A2A (Agent-to-Agent) Protocol - where I built a LangGraph agent that autonomously decides when to delegate tasks to a backend A2A-compliant agent service equipped with web search, ArXiv research, and RAG capabilities. The system handles async communication, multi-turn conversations, and intelligent routing decisions. 𝗧𝗵𝗿𝗲𝗲 𝗞𝗲𝘆 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴𝘀: 1️⃣ 𝘗𝘳𝘰𝘵𝘰𝘤𝘰𝘭 𝘚𝘵𝘢𝘯𝘥𝘢𝘳𝘥𝘪𝘻𝘢𝘵𝘪𝘰𝘯 𝘌𝘯𝘢𝘣𝘭𝘦𝘴 𝘊𝘰𝘮𝘱𝘰𝘴𝘢𝘣𝘪𝘭𝘪𝘵𝘺 – A2A provides a universal language for agents, much like HTTP did for web services. Using AgentCards for capability discovery, agents can dynamically understand what other agents can do before invoking them, enabling true interoperability across different frameworks. 2️⃣ 𝘐𝘯𝘵𝘦𝘭𝘭𝘪𝘨𝘦𝘯𝘵 𝘙𝘰𝘶𝘵𝘪𝘯𝘨 𝘪𝘴 𝘊𝘳𝘪𝘵𝘪𝘤𝘢𝘭 – The most impressive aspect wasn't just tool use, but tool restraint. The agent autonomously evaluates whether external knowledge is needed or if it can answer directly. This decision-making capability prevents unnecessary API calls and demonstrates genuine autonomous behavior. 3️⃣ 𝘈𝘴𝘺𝘯𝘤 𝘗𝘢𝘵𝘵𝘦𝘳𝘯𝘴 𝘢𝘳𝘦 𝘌𝘷𝘦𝘳𝘺𝘸𝘩𝘦𝘳𝘦 – Implementing proper async/await patterns throughout the stack was essential for non-blocking I/O. This architectural choice significantly impacts both performance and system reliability when orchestrating multiple agent communications. Check out: Git: https://lnkd.in/gFGeYG4s Loom: https://lnkd.in/gpxv9MtX Thanks to AI Makerspace for the wonderful content and education.

𝐔𝐧𝐝𝐞𝐫𝐬𝐭𝐚𝐧𝐝𝐢𝐧𝐠 𝐀2𝐀 𝐏𝐫𝐨𝐭𝐨𝐜𝐨𝐥𝐬 𝐟𝐨𝐫 𝐌𝐮𝐥𝐭𝐢-𝐀𝐠𝐞𝐧𝐭 𝐀𝐈 𝐒𝐲𝐬𝐭𝐞𝐦𝐬 I've been experimenting with A2A protocols in a couple of projects, and recently built something in LangGraph to explore how they work in practice. Haven't jumped across frameworks yet, kept it simple with LangGraph, but the protocol's advantages showed up even in that setup. Here's the thing, when you build an agent in LangGraph and your teammate builds one in CrewAI, they're speaking different languages. You could try wrapping one as a tool inside the other, but that gets messy fast. You end up exposing implementation details you'd rather keep private, or worse, rebuilding the same functionality just to make things compatible. 𝐓𝐡𝐢𝐬 𝐢𝐬 𝐰𝐡𝐞𝐫𝐞 𝐀2𝐀 (𝐀𝐠𝐞𝐧𝐭-𝐭𝐨-𝐀𝐠𝐞𝐧𝐭) 𝐩𝐫𝐨𝐭𝐨𝐜𝐨𝐥𝐬 𝐜𝐨𝐦𝐞 𝐢𝐧. Think of A2A like a universal translator for AI agents. It creates a standardized way for agents to communicate without needing to understand each other's internal code. The remote server keeps its logic hidden, but exposes a clear interface that any other agent can use. The real win? 𝐑𝐞𝐮𝐬𝐚𝐛𝐢𝐥𝐢𝐭𝐲. If someone's already built a capable agent that does exactly what you need, you can connect to it through A2A instead of reinventing the wheel. No framework gymnastics required. A2A also makes collaboration across teams and companies much smoother. Everyone agrees on how to send tasks and receive results, regardless of what tech stack they're using underneath. It's more direct and scalable than trying to force different frameworks to play nice with each other. 𝐓𝐡𝐫𝐞𝐞 𝐊𝐞𝐲 𝐋𝐞𝐬𝐬𝐨𝐧𝐬 𝐈'𝐯𝐞 𝐋𝐞𝐚𝐫𝐧𝐞𝐝: 𝐂𝐫𝐨𝐬𝐬-𝐟𝐫𝐚𝐦𝐞𝐰𝐨𝐫𝐤 𝐜𝐨𝐦𝐦𝐮𝐧𝐢𝐜𝐚𝐭𝐢𝐨𝐧 - A2A makes it realistic for agents built on completely different frameworks to talk safely and predictably. You're not locked into one ecosystem anymore. 𝐀𝐠𝐞𝐧𝐭𝐂𝐚𝐫𝐝𝐬 𝐚𝐫𝐞 𝐲𝐨𝐮𝐫 𝐡𝐚𝐧𝐝𝐬𝐡𝐚𝐤𝐞 - The AgentCard acts like a profile or introduction, defining who the agent is and exactly how to communicate with it. It's the first thing agents exchange to establish trust. 𝐒𝐭𝐫𝐞𝐚𝐦𝐢𝐧𝐠 𝐦𝐚𝐭𝐭𝐞𝐫𝐬 𝐟𝐨𝐫 𝐔𝐗 - Streaming outputs can make multi-agent systems feel responsive and human-like during long reasoning tasks. Instead of waiting in silence, you see progress in real-time, which makes a huge difference in how the system feels to use. Another shout-out to AI Makerspace - this isn't just a learning platform, it's a community of curious builders who genuinely support each other's growth.

Moving from prototype to production this week taught me that sustainable AI systems require deliberate architectural choices. Here's what made the difference: 1. Caching Strategy: Exact match caching = fast but brittle. Semantic caching matches on meaning not text, dramatically improving cache hit rates while keeping responses fresh. 2. Guardrails as Checkpoints: - Preprocessing (validation)→ filter bad inputs before they hit your agent - Postprocessing (refinement) → ensure outputs meet quality standards This gives you deterministic control in a probabilistic system. 3. Agent Architecture: Simple agents for quick, single-hop queries. Refined agents when complex reasoning justifies extra latency. Most production systems route dynamically based on query complexity. Bottom Line Production isn't about being clever: it's about optimizing for cost, quality, and experience simultaneously. 🔗 Full code: https://lnkd.in/dcfsenpR Big shout out to AI Makerspace, let's keep building! 🚀

𝐁𝐮𝐢𝐥𝐝𝐢𝐧𝐠 𝐏𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧-𝐑𝐞𝐚𝐝𝐲 𝐋𝐚𝐧𝐠𝐆𝐫𝐚𝐩𝐡 𝐀𝐩𝐩𝐥𝐢𝐜𝐚𝐭𝐢𝐨𝐧𝐬: 𝐂𝐚𝐜𝐡𝐢𝐧𝐠, 𝐆𝐮𝐚𝐫𝐝𝐫𝐚𝐢𝐥𝐬, 𝐚𝐧𝐝 𝐎𝐛𝐬𝐞𝐫𝐯𝐚𝐛𝐢𝐥𝐢𝐭𝐲 This week I explored how to take a LangGraph agent from a clean notebook demo to something that feels truly production ready with caching, observability, and guardrails built right in. When I started connecting LangGraph agents to real data like PDFs, APIs, or Arxiv searches, every millisecond and every API call began to matter. So I introduced embedding and LLM caching, a simple but powerful step that makes repeated work free. In one test, cached responses ran up to 16× faster, cutting latency and cost dramatically. Then I added LangGraph agents, both a Simple Agent and a Helpfulness Agent. The first focused on fast, tool-driven answers; the second on reflective refinement. Watching them run side by side was eye-opening: helpfulness added reasoning quality but also 25 percent more time. It's a trade-off every builder must measure. Finally, I layered in Guardrails AI for production safety with topic restriction, PII redaction, jailbreak detection, and factuality checks. This turned the workflow into a safe pipeline: 𝐔𝐬𝐞𝐫 𝐈𝐧𝐩𝐮𝐭 → 𝐈𝐧𝐩𝐮𝐭 𝐆𝐮𝐚𝐫𝐝𝐬 → 𝐀𝐠𝐞𝐧𝐭 → 𝐓𝐨𝐨𝐥𝐬 → 𝐎𝐮𝐭𝐩𝐮𝐭 𝐆𝐮𝐚𝐫𝐝𝐬 → 𝐑𝐞𝐬𝐩𝐨𝐧𝐬𝐞 At this point, it felt less like a prototype and more like an LLMOps system: cached, monitored, safe, and observable via LangSmith. 💡 𝐋𝐞𝐬𝐬𝐨𝐧𝐬 𝐋𝐞𝐚𝐫𝐧𝐞𝐝 Caching transforms a working demo into a scalable system. Reflection loops add quality but must be tuned for cost and latency. Guardrails are not optional in user-facing agents — they define trust. Observability through LangSmith reveals performance bottlenecks fast. Tool integration is powerful, but smart routing makes or breaks speed. Every production agent is a balance between accuracy, speed, and safety. 🔍 𝐑𝐞𝐟𝐥𝐞𝐜𝐭𝐢𝐨𝐧 𝐪𝐮𝐞𝐬𝐭𝐢𝐨𝐧: How do I find the right balance between tool use, reflection loops, and caching efficiency — and what's the real cost of thinking twice versus responding fast? Huge shout-out of AI Makerspace, where 'production-ready' stops being theoretical and starts being something you actually build and ship.

🚀  Building Agent Ecosystems with A2A Protocol 🤖 I just wrapped up an intense build around the A2A (Agent-to-Agent) Protocol and it has transformed how I think about AI systems. We always talk about multi-agent setups, but A2A makes that real: agents that discover, delegate, and collaborate like micro-services. ⚙️ What I Built 🔹 LangGraph Client Agent – demonstrates agents as tools via the A2A protocol. 🔹 CrewAI Persona System – 4 unique personas (Dr. Elena, Marcus, Priya, James) calling the same A2A server seamlessly. 🔹 LangGraph Studio Integration – live graph tracing for debugging and visualization. 🔹 Makefile Automation – spin up server, client, and Studio in one command. 🌟 The Technical Challenge: How do you enable agents built with different frameworks (LangGraph, CrewAI) to communicate seamlessly? The answer: A2A protocol with AgentCard-based discovery. 🧩 Key Engineering Insights 1️⃣ AgentCard as Discovery Mechanism:  Instead of hardcoded dependencies, agents discover capabilities at runtime through AgentCards. This enables loose coupling - I can swap Tavily for Bing without touching client code. 2️⃣  True Framework Interoperability A2A works with async frameworks (LangGraph) and sync frameworks (CrewAI) because it's just HTTP. I used ThreadPoolExecutor to bridge async A2A SDK with sync CrewAI - proving true framework interoperability. 3️⃣ Server-Side Quality Gates The helpfulness evaluation loop runs on the server, benefiting all clients. One quality improvement helps everyone - that's the DRY principle applied to AI agents. 💡Clients don't need to know implementation details.  My LangGraph client doesn't know the server uses Tavily. My CrewAI personas don't know about ArXiv. They just know "this server can search" from the AgentCard. This is abstraction at scale - the same principle that made microservices successful, now applied to AI agents. 🧠 What’s Next • A2A authentication & trust mechanisms 🔐 • Error recovery and retry orchestration • Consensus & coordination across agent networks Huge thanks to AI Makerspace, Dr. Greg Loughnane, Chris "The Wiz 🪄" Alexiuk, Ovo Okpubuluku, Laura Funderburk, Chris Lusk 🚀, Mark Walker for pushing us to think beyond single agents. 🙏 and appreciation to Google for the A2A protocol and CrewAI, LangChain for awesome tools. 🎥 Demo: https://lnkd.in/gpz7yhTD 📂 Code: https://lnkd.in/g2evvCyb #AI #LangGraph #CrewAI #AIE8 #AIEngineering #AgentProtocols #MachineLearning #AIMakerspace #Microservices #LLM

🚀 Building Production-Safe LLM Systems: Caching + Guardrails at Scale I just wrapped up Session 16 of the AI Engineering Bootcamp with AI Makerspace, tackling one of the toughest challenges in real-world LLM systems: 👉 Can you make them both FAST and SAFE? Most production teams pick one. I decided to prove you can have both. 🔍 The Challenge: In production, every millisecond counts. Users expect sub-second responses, but guardrails, validation, and quality checks add latency. Balancing these is an engineering problem, not just a prompt problem. 💡 What I Built: ⚙️ Two-Tier Production Caching • Embedding cache (LocalFileStore) + LLM response cache (InMemoryCache) • 10× faster on cache hits, 40% hit rate under realistic workloads • Discovered 4 key scaling pain points: invalidation, size limits, coordination, and cold-start impact 🧠 LangGraph Agent Architecture Comparison • Simple Agent: 1-3s latency, ~$0.001/query → optimized for speed • Helpful Agent: 3-10s latency, ~$0.003/query → optimized for quality • 🧩 Insight: Architecture should align with SLA goals, not generic “best practices” 🛡️ Production-Safe Guarded Agent (Guardrails AI) • 5-layer defense: jailbreaks, topic limits, PII blocks, profanity filter, factuality check • 18 adversarial tests → 100% blocked, 0% false positives •⚡ Async validation reduced guard overhead by 60% (400ms → 150ms) ✨ Key Lesson Security and performance aren’t opposites — they’re design variables. By running validations in parallel and enabling factuality checks only for RAG flows, I built an agent that’s both enterprise-secure and production-fast. 📈 Results ✅ 100% security effectiveness ✅ 20% latency improvement ✅ Production-readiness score: 9/10 🧩 Key Takeaway The gap between demo code and production systems isn’t size - it’s trade-offs, failure design, and realistic optimization. 📂 GitHub: https://lnkd.in/gZc3G_Jg 🎥 Loom Walkthrough: https://lnkd.in/g7MRSSzt Huge thanks to the AI Makerspace team, Dr. Greg Loughnane, Chris "The Wiz 🪄" Alexiuk, Ovo Okpubuluku, Laura Funderburk, Mark Walker, Can Temizyurek for pushing us beyond tutorials into real AI engineering and to Guardrails AI for an incredible tool. This is how you build AI systems that actually ship. #AIEngineering #LLMOps #ProductionAI #LangChain #LangGraph #GuardrailsAI #MachineLearning #SoftwareEngineering

💸 Making Agents Faster and Safer w/ Caching + Guardrails 🚂 This week, I focused on taking an AI agent from prototype to production-ready by tackling two of the biggest challenges in real-world AI systems: performance and safety. Using LangGraph, I built a pipeline that: ⚡ Implements caching to reuse embeddings and responses instead of recalculating them. 🛡️ Integrates the Guardrails API to validate every input and output — filtering out jailbreaks, PII, and off-topic requests. 🧠 Connects RAG, Tavily Search, and Arxiv tools to reason across documents and sources intelligently. 🎬 Demo: https://lnkd.in/etwE_tVJ 👩🏻💻 Github: https://lnkd.in/eu7yiETy 💡 One experiment I did: I ran a cache performance test on repeated document queries: ⏱️ First run: 577 ms ⚡ Cached run: 278 ms — nearly 2× faster, and with zero additional API calls. Then, I stress-tested safety by sending edge cases: ❌ Off-topic and jailbreak prompts were blocked. 🔒 Personal Identifying information inputs were automatically redacted. ✅ Legitimate questions passed through normally. 📈 Overall, caching is about efficiency and predictability at scale, while guardrails transform AI from “smart” to safe, compliant, and trustworthy. Keeping Agents safe w/AI Makerspace 👩🔬 #LangGraph #GuardrailsAI #Caching #RAG #AIEngineering #LLMOps #AIMakerspace

🚀 Just Built a Production-Ready RAG System with AI Guardrails! 🛡️ Excited to share my latest project from AI Makerspace's AI Engineering cohort—a comprehensive exploration of what it really takes to deploy LLM applications in production. This goes way beyond the basic chatbot tutorial! 🔥 🏗️ What I Built: A multi-agent RAG system with enterprise-grade features: ✨ 14.4x performance boost through intelligent multi-level caching 🤖 LangGraph orchestration with dynamic tool selection (RAG + Tavily + Arxiv) 🛡️ 6-layer Guardrails AI validation (jailbreak detection, PII protection, factuality checks) 📊 Full observability with LangSmith tracing for production monitoring 🔧 Tech Stack: LangChain | LangGraph | Guardrails AI | OpenAI | Qdrant | Tavily | LangSmith | Python | uv This project taught me that the hard part of AI engineering isn't the model—it's the 90% of infrastructure around it: caching strategies, safety validation, monitoring, error handling, and cost optimization. Production AI is an engineering discipline! 🏗️Huge shoutout to AI Makerspace for the incredible curriculum and hands-on learning approach. The gap between tutorial code and production-ready systems is massive, and this cohort bridges it beautifully! 🙏 Check out the full project on my GitHub (link in comments) 👇 Github link: https://lnkd.in/eaUGRhSW demo video: https://lnkd.in/eyjCEj2G \#AIEngineering #LLMOps #ProductionAI #RAG #LangChain #LangGraph #GuardrailsAI #MachineLearning #AI #LearningInPublic #BuildInPublic