Streamline LLM Debugging with Context Excavator

🧠 Built a Codebase RAG — Chat With Any GitHub Repo Upload any GitHub repo as a ZIP → Ask questions about it in plain English. "How does authentication work?" "List all functions in main.py" "Explain the upload route" It actually understands your code. Here's how it works: → Extracts all code files from the ZIP → Chunks them intelligently using Python's AST parser (function-level, not random splits)→ Converts each chunk into vector embeddings → Stores in ChromaDB (vector database)→ Your question gets embedded → semantic search finds the most relevant chunks → Groq LLM reads those chunks and answers The LLM never sees the full codebase — only the top6most relevant chunks retrieved by vector similarity. That's RAG. Tech Stack: ⚡ FastAPI + React 🧬 sentence-transformers (all-MiniLM-L6-v2) 🗄️ ChromaDB 🤖 Groq (llama-3.1-8b-instant) This is my AI project as I work through my AI/ML learning roadmap. GitHub → https://lnkd.in/gfbyykeG #RAG #AI #Python #FastAPI #React #LLM #GenerativeAI #BuildInPublic

I’ve been building an AI agent system from scratch (Jan 2026 – Present). Not relying on pre-built frameworks — designing and implementing the internals myself. Here’s what I’ve built so far: 🧠 ReAct agent loop (Reason → Act → Observe → Repeat) 💬 Conversation memory (sliding window + LLM summarization) ⚙️ Sandboxed Python execution inside the agent 🤖 Multi-agent pipeline (Planner → Executor → Synthesizer) 🔁 Self-healing agents (retry logic, critique agents, graceful degradation) 📊 Structured JSON outputs with LLM-as-a-Judge evaluation The most interesting part: When Python code fails, a “Critique Agent” reads the traceback, fixes the issue, and re-runs it automatically. When context grows too large, the system dynamically reroutes to a local Ollama instance — enabling load balancing and protecting API limits. All of this runs on the free tier using Groq. Still in progress: → Long-term memory with ChromaDB → Parallel tool execution → Human-in-the-loop approval workflows → End-to-end pipeline: research → write → review GitHub: https://lnkd.in/ev8e9kGQ #AI #LLM #AgentAI #Python #MachineLearning #SystemDesign #BuildInPublic

Built an AI agent that explores codebases and answers questions about them. No LangChain. No frameworks. Just raw OpenAI API. The agent has 3 tools: → list_files: explore directory structure → read_file: inspect file contents   → search_code: find where functions/classes are defined Ask it "How does the chunker work?" and it: 1. Lists files to understand structure 2. Searches for "chunk"  3. Reads the relevant file 4. Explains the implementation with line references Why raw API instead of LangChain? 50 lines of code taught me: - How tool calls are parsed - How the ReAct loop actually works - How to handle failures Frameworks hide this. Understanding primitives first = better debugging later. Code: https://lnkd.in/g8sJnA2Y Previous RAG used as codebase - https://lnkd.in/gABgPcFf What's the most useful agent you've built or seen? #AI #LLM #Agents #Python #OpenAI #BuildInPublic #SoftwareEngineering #AIEngineering #Langchain

I built an AI agent from scratch. No LangChain. No LangGraph. No CrewAI. Just Python, Gemini 2.5 Flash, and raw tool calling. Here's what I learned that no framework tutorial will teach you: 1. The agentic loop is embarrassingly simple Build messages → call LLM → if tool_call → execute → feed result back → repeat. That's it. Every framework is just a wrapper around this. Once you see it raw, you can never unsee it. 2. Frameworks hide your bugs from you When something breaks in LangChain, you're debugging the framework. When something breaks in raw Python, you're debugging your logic. Big difference. One makes you smarter. One makes you dependent. 3. Tool schema design is where agents actually fail The LLM doesn't call the wrong tool because it's dumb. It calls the wrong tool because your schema description was ambiguous. Write your tool descriptions like you're explaining them to a junior dev on their first day. Precise. No assumptions. 4. 50 lines of Python is enough to go to production My personal concierge agent — the one that lives on my portfolio, captures leads, and pings my phone instantly — is ~50 lines. No overhead. No magic. Just code I fully understand and can debug at 2am. 5. You should build one without a framework at least once Not because frameworks are bad. LangGraph is excellent. I'm using it next. But if you've never written the raw loop yourself, you're flying blind. You're trusting abstractions you don't understand. Build it raw first. Then use the framework. You'll use it 10x better. --- Full source code in the comments — ~50 lines, no magic, just the loop. Follow along if you're into agentic AI and building real things, not just demos. #AgenticAI #Python #BuildingInPublic #LLM #SoftwareEngineering

Most RAG systems don’t fail at retrieval. They fail before that. You ingest documents → chunk → store → retrieve… And everything looks fine. Until your AI starts giving bad answers. The real problem? 👉 Garbage goes into your vector database. And once it’s there, your system is quietly broken. So I built Gweta. An open-source Python framework that acts as a quality gate for RAG pipelines. Instead of blindly ingesting data, Gweta: - Validates extraction quality (no gibberish, no broken text) - Filters irrelevant chunks based on system intent - Enforces domain rules (what should and shouldn’t exist) - Monitors knowledge base health over time So your pipeline becomes: Document → Gweta → Clean, relevant knowledge → Better answers Not: Document → Vector DB → Debugging hallucinations later If you’re building with RAG, you don’t need more data. You need better data going in. Docs: https://lnkd.in/eKSdMNCu Still early, but already solving a problem I kept hitting in real systems. #RAG #AIEngineering #Python #OpenSource #LLM #MachineLearning #BuildInPublic

Project: AI Document Search using RAG Developed an AI-based document search system using Retrieval-Augmented Generation (RAG). The application allows users to upload PDF, DOCX, and TXT files and ask questions based on the document content. The system retrieves relevant information and generates answers from the uploaded data. 🔹 Tech Stack   Python | LangChain | Google Gemini | FAISS | Streamlit  🔹 Highlights   • Multi-file document upload   • Data retrieval using FAISS vector database   • Context-based information analysis from documents   • Data-driven question answering using RAG pipeline   • Simple chat-based interface built with Streamlit 🔗 GitHub Repository   https://lnkd.in/gfZbz8pv  #Python #DataAnalytics #RAG #AI #LangChain #Streamlit

Most people getting into AI hear terms like LangChain, CrewAI, and Python and assume they’re all doing the same thing. They’re not, and understanding the difference changes how you actually build. Python is the foundation. It’s where everything runs. Data pipelines, model interaction, APIs, integrations. If you don’t understand Python, every framework on top starts to feel like a black box. LangChain sits above that as an application layer. It helps structure LLM-powered systems, handling prompts, memory, tool usage, and RAG pipelines. It’s not the only way to build, but it gives you a strong starting point for orchestrating behavior. CrewAI goes a step further into coordination. It focuses on multi-agent systems, where different agents take on roles, delegate tasks, and collaborate. Still early in many production environments, but directionally where things are going. Beyond these, real systems rely on more pieces. Tools like LlamaIndex for data retrieval, FastAPI for APIs, Hugging Face for models, vector databases like Pinecone or Weaviate, and layers for caching, observability, and optimization. What I’ve noticed is people rush into frameworks without understanding what’s underneath. But once you see the flow, Python first, then application logic, then coordination, everything starts to make a lot more sense. #AI #MachineLearning #LangChain #CrewAI #Python #RAG #LLM #AIDevelopment

"Stop breaking your AI's logic with 'Blind' Chunking" Most RAG (Retrieval-Augmented Generation) systems fail because they treat code like plain text. When you slice a Python script every 500 characters, you risk cutting a function in half. This leads to LLM "hallucinations" because the model only sees partial logic. How it works: AST Parsing: Instead of raw text slicing, I use Python's Abstract Syntax Tree (AST) to identify logical boundaries (Classes and Functions). Token-Aware Packing: Using the tiktoken tokenizer, I calculate exact costs and pack these logical blocks into chunks that never exceed the model’s context window. Semantic Retrieval: I integrated ChromaDB to store these chunks as high-dimensional vectors, enabling semantic search instead of just keyword matching. The Result: A context-aware ingestion pipeline that ensures the LLM always receives complete, logical code blocks, drastically increasing accuracy and reducing errors. Tech Stack: FastAPI | ChromaDB | Sentence-Transformers | Tiktoken Check out the repo here: https://lnkd.in/gkVYmnwW #AI #GenerativeAI #Python #FastAPI #MachineLearning #RAG #SoftwareEngineering

Installing an AI agent runtime shouldn't require reading 3 docs pages. So we made it one command. curl -fsSL https://lnkd.in/dZSQ5Mqc | bash That's it. pydantic-deepagents — the modular agent runtime for Python — installed. Here's what the install experience looked like before: 1. Install Python (which version? 3.10? 3.12?) 2. Create a virtual environment 3. pip install pydantic-deep[cli] 4. Figure out why `pydantic-deep` isn't in your PATH 5. Realize textual wasn't included in the base install 6. Install again with the right extras 7. Try again Seven steps. Fifteen minutes minimum. That's before you've even seen the tool. What install.sh actually does: 1. Detects whether `uv` is already installed 2. If not: installs `uv` automatically from astral.sh 3. Runs `uv tool install "pydantic-deep[cli]"` — no virtualenv management needed 4. Verifies the binary is accessible 5. Prints PATH instructions if needed (and explains exactly how to fix it) After the first install, updating is one command too: pydantic-deep update That's brew upgrade for AI agents. It uses `uv tool upgrade` if uv is available, falls back to pip. No version juggling. We also added startup update notifications. Every time pydantic-deep starts, it quietly checks PyPI for a newer version (2-second timeout, never blocks startup). If one exists, you see: Checks are cached for 24 hours so it doesn't hit PyPI on every single invocation. The features we built this week — context window awareness, smarter history search, agent loop detection — none of it matters if the install experience drives people away at step 1. Tomorrow: same agent, different environment. Docker sandbox. What's the most painful install experience you've had with an AI or ML tool? (I'll go first: a certain GPU-accelerated library that required matching CUDA versions, driver versions, and Python versions to a compatibility matrix that was 2 versions out of date.) Pydantic | Vstorm #Python #DeveloperExperience #OpenSource

Today's topic is a tool combo breakdown focusing on three exciting combinations that can revolutionize your workflow and save you time. Whether it’s integrating Claude Code with Obsidian for a seamless knowledge management system or harnessing n8n combined with the Claude API to automate complex tasks, these tools offer specific benefits. Let's dive into one of our options: using Python along with the Claude API. This combo allows developers to leverage AI capabilities directly within their existing workflows. Here’s how you can set it up: 1. **Setup**: First, ensure you have Python installed on your machine. You'll also need n8n and Claude Code plugins for n8n. 2. **Write Your Script**: Start by writing a simple Python script that uses the Claude API to process text inputs. For example: ```python import n8n from claude import ClaudeAPI # Initialize Claude API cl = ClaudeAPI() # Function to get AI generated response def get_response(prompt): response = cl.get_completion(prompt) return response # Example usage of the function result = get_response("What's the weather like in New York today?") print(result) 3. **Integrate with Obsidian**: Next, you can integrate this script with Obsidian using n8n to automate tasks. This setup can save significant time and effort, reducing manual processing and allowing for more efficient workflows. Would you be interested in exploring further AI integration opportunities like this one? Let us know your thoughts or challenges in the comments below. #ClaudeCode #AIAutomation #AITools #BuildWithAI #loopfeedai