rst-queue v0.1.6: High-Performance Async Queue System for Python

After experiencing issues with RAG demos breaking when handling real-world data, I dedicated my weekend to rebuilding the stack from scratch. Many tutorials simplify RAG to just Vector DB + Prompt, but in reality, semantic search can be noisy, and "vibes-based" retrieval often leads to hallucinations. My goal was to create a Compliance RAG pipeline capable of managing rigid, regulatory language without failure. Here’s the "v1" of my personal project and the architecture behind it: The Build: 📌The Hybrid Layer: I combined Qdrant with BM25. This approach ensures that if a compliance document references "Section 402.b," keyword search can capture it even if an embedding might miss it. 📌The Reranker: I incorporated a Cross-Encoder layer. Although slower than a vector lookup, it guarantees that the LLM only processes the most relevant context, significantly enhancing accuracy. 📌The Frontend: I developed a decoupled React + Vite UI utilizing Server-Sent Events (SSE) to prioritize real-time token streaming and eliminate frustrating spinning loaders. The Tech Stack: - Language: Python (FastAPI), Langgraph, - Embeddings: BGE + OpenAI. - Database: Qdrant(Vector Database) - Deployment: Successfully launched on AWS EC2 using Nginx, Docker and a GitHub Actions pipeline. 🚀Project Demo link: https://aryangupta.work/ 🧠 What I Learned: The LLM is actually the simplest component of the stack—serving primarily as a formatter. The true "intelligence" resides in the retrieval and ranking logic. If your retrieval is only 60% accurate, your LLM will also be limited to that accuracy, regardless of prompt quality. I'm pleased with the reranking latency results, though I'm still fine-tuning the hybrid weights. For those developing RAG systems: How do you manage the latency trade-off of a Cross-Encoder versus the precision benefits? #BuildInPublic #RAG #Python #FastAPI #MachineLearning #LLMOps #Qdrant #SoftwareEngineering

Half my context window was gone before I typed a single prompt. Claude Code indexed my entire monorepo at session start — Python files, Airflow DAGs, three months of task logs. Then it generated a migration that referenced a table that doesn't exist. I spent weeks rebuilding my project setup from scratch. Token usage dropped over 60%. But the real win was rework time going down significantly. Here's what actually moved the needle: - permissions.deny in settings.json — the official way to block files Claude shouldn't read. Read(./.env), Read(./airflow/logs/), Read(./.venv/). The airflow/logs line alone cut 15%. - .claudeignore — an unofficial shortcut that works like .gitignore. Not in the docs yet, but a lot of people use it. Same result, cleaner syntax. - CLAUDE.md hierarchy — root file under 200 lines. Subdirectory files load only when needed. Past 200 lines, Claude starts treating your instructions as optional. - MCP servers (BigQuery + Airflow) — live database access without pre-loading schemas into context. Deferred by default, costs almost nothing until Claude actually queries one. - Skills & agents — on-demand workflows at ~100 tokens each instead of 3,000-5,000 tokens baked into CLAUDE.md every session. - /compact and /context — the two commands I run multiple times a day to manage what's eating my context window. 30 minutes of setup. Every session after that starts lean. Full walkthrough with real configs from a data pipeline project: https://lnkd.in/gaNuSUta -- What does your Claude Code project setup look like? Are you using permissions.deny or .claudeignore — or just letting it index everything? #AICoding #SoftwareEngineering #DataEngineering #ClaudeCode #DeveloperTools #AIEngineering #SystemDesign

Shallow Copy vs Deep Copy — The 2 AM Bug Trap 🛑 Most developers think they understand copying objects, until their original data mysteriously changes. That’s not a bug, that’s memory behavior biting you. → Shallow Copy Creates a new container, but nested objects are still shared (by reference) 👉 Change nested data → both copies change. Best for: Flat, simple data. → Deep Copy Creates a completely independent clone, everything is copied recursively. 👉 Change anything → original stays untouched Best for: Complex, nested structures. 💡 Rule of Thumb Shallow → when you only need a surface-level copy Deep → when you need true isolation ⚠️ The real trap: Most bugs aren’t syntax errors. They come from not understanding how data behaves in memory. If you’ve ever spent hours debugging only to realize it was a shallow copy issue. Welcome to the club 😄 #Python #Python3 #Programming #SoftwareEngineering #CleanCode #Debugging #TechTips #PythonDeveloper  #BackendDevelopment

📗 Logfire vs Grafana — Choosing the Right Observability Tool When it comes to monitoring and debugging applications, picking the right tool can make a huge difference. Here’s a simple breakdown ✅ Logfire Perfect for developers who want a quick, Python-focused setup ✔️ Fast integration (especially with FastAPI) ✔️ Developer-friendly ✔️ Great for rapid debugging & insights ✅ Grafana Built for scalable, enterprise-level observability ✔️ Powerful dashboards & visualization ✔️ Supports multiple data sources ✔️ Ideal for large-scale systems 🌈 Quick takeaway: Logfire = Start fast ⚡ Grafana = Scale smart 📈 If you're building fast and iterating quickly → Logfire If you're managing complex systems at scale → Grafana #BackendDevelopment #DevOps #Observability #Grafana #Python #FastAPI #SoftwareEngineering

I built a RAG layer for Claude Code that cuts token usage by 80–90%                            Most devs using Claude Code don't realize they're burning tokens on files Claude doesn't need to read.                                                Ask Claude "how does auth work?" and it reads 3 full files — 1,500+ tokens just to answer with 40 relevant lines. I fixed that. What I built: A local hybrid RAG system that sits between Claude and your codebase:  → Late chunking — splits every file into overlapping 40-line windows  → Dense retrieval — semantic search with all-MiniLM-L6-v2 (runs fully local, no API key)  → BM25 sparse retrieval — keyword matching for exact symbol names  → Cross-encoder reranking — picks the 3 best chunks from 20 candidates  → File watcher — auto-rebuilds the index within 2 seconds of any file save Claude Code reads the CLAUDE.md and knows: run pip package before opening any file. It gets back 3 precise snippets with file path + line range. It reads only those lines. Nothing else. Real numbers on my Volta Engine project (76 files):  - Without RAG: 17,235 chars across 3 files for one question  - With RAG: 3,073 chars the exact 3 chunks that matter  - 82% fewer tokens. Same answer. The whole thing runs offline. No cloud embeddings. No API calls. Just a one time pip install and run it. Stack: sentence-transformers · rank-bm25 · watchdog · Python If you use Claude Code daily on a real codebase, this pays for itself in the first session. DM me if you want the scripts. 🧠  #AI #ClaudeCode #RAG #DeveloperTools #Python #LLM #Productivity

🚀 I just deployed my own CLI toolbox to PyPI — globally available — because I was DONE doing the same boring tasks every day. You know that feeling when you keep saying “I’ll automate this later”… and then you do it again manually? Yeah. That broke me. So instead of writing another random script, I built My Instant Toolbox — one CLI to rule all my everyday automations. Now, messy folders? One command. Need backups right now? One command. Curious if your system is dying mid‑work? One command. Publishing to PyPI? Still… one command. What this thing actually does 👇 🧹 Cleans chaos – Auto‑organizes folders by file type 🏷️ Renames at scale – Hundreds of files, renamed in seconds 🔒 Backs up smart – Timestamped ZIP backups, zero brain cells required 📊 Shows the truth – Live CPU, RAM, Disk stats in a beautiful terminal dashboard 📦 Ships fast – Build + publish Python packages like a cheat code Built with Python + Typer + Rich, because productivity shouldn’t look ugly. I deployed it to PyPI, so anyone in the world can install it and use it instantly. 📦 pip install my-instant-toolbox 🔗 Code & docs: https://lnkd.in/g8ur7wT6 This started as “let me save 10 minutes” It turned into “why wasn’t this always one command?” If you live in the terminal and hate repetitive work — this one’s for you 🛠️ #Python #OpenSource #CLI #Automation #DevOps #BuildInPublic #SoftwareEngineering

This week I stopped just solving problems and started actually understanding my tools. the thing nobody tells you early on: you can know the logic perfectly and still write terrible code because you're reinventing what already exists. that was me. so this week was all about STL C++ Standard Template Library. what is STL and why does it matter? STL is a collection of ready made data structures and algorithms built into C++. instead of manually building a hashmap or a dynamic array from scratch, you use what's already optimized and battle-tested. map, unordered_map, vector, stack, queue, set these aren't just containers. knowing which one to use and when is the difference between a clean O(n) solution and a messy O(n²) one. in a real interview, you don't have time to build from scratch. you need to know your tools. what I actually worked on this week: → map vs unordered_map ordered vs O(1) lookup tradeoffs → adjacency list using map<int, vector<int>> → prefix sum pattern → combining hashmap + modular arithmetic together problems solved: → LRU Cache (medium) finally understood how to combine hashmap + doubly linked list → Sum of Distances (medium) → Make Sum Divisible by P (medium) → Minimum Operations to Make Array Sum Divisible by K stuck on: LFU Cache LRU felt hard until it clicked. LFU is a whole different beast. still working on it. the honest part: "Make Sum Divisible by P" took me 2.5+ hours. I got TLE, then WA, fixed both, and finally understood why the solution works. slow? yes. but I didn't copy a solution I earned it. my LeetCode if you want to see the journey: https://lnkd.in/ghKx4CgM now a genuine question for the experienced folks here when you were learning DSA, how did you balance depth vs speed? spending 2-3 hours on one problem to fully understand it, or timebox it and move on? would love brutal honest takes. drop it in the comments 👇 #LeetCode #DSA #CPP #STL #LearningInPublic #BackendDevelopment #SoftwareEngineering #100DaysOfCode

I built an MCP server that roasts your pull requests You know that PR you shipped on Friday at 5pm with the description "misc fixes"? Yeah, this tool has opinions about that. pr-roast-mcp is an MCP server that reads any GitHub PR - the diff, the stats, the description (or lack thereof) - and delivers a brutally honest code review. With a severity rating from 🔥 to 🔥🔥🔥🔥🔥.  ▎ "Your tests are thorough. Like, suspiciously thorough. 156 lines for a POST endpoint?  ▎ You're basically writing a dissertation on HTTP status codes."  ▎  ▎ "849 lines added, 7 removed. That's 121:1 ratio. For a 'bonus feature,' this  ▎ sprawls."  ▎ It's always technically accurate though. Every roast points at real issues -naming, complexity, missing edge cases, over-engineering. It just delivers the feedback the way your most senior engineer would after their third coffee. It always ends with one genuine compliment. Mine was about rounding edge cases in bonus calculations. Small wins. Two tools, ~150 lines of Python:  - roast_pr - point it at any PR number or URL  - roast_my_prs - lists your PRs so you can pick a victim Uses gh CLI to fetch the diff, Claude Haiku for the roast. Setup is one line. We've been using it in our team Slack before merges. Morale has either improved or collapsed, depending on who you ask. Code: https://lnkd.in/gHcZFTqB #buildInPublic #AI #claude #haiku #MCP #Python #DevTools #CodeReview #OpenSource

Three LangChain labs that mirror real production failures — DataExpert.io × Zach Wilson I’ve been working through DataExpert’s LangChain track with Zach Wilson. Three assignments really stood out—they’re not about “prompt tweaks,” but about what actually breaks when tools and agents are wired incorrectly. 🔹 Lab 1 — Context overflow from a “database” tool A lookup tool was dumping the entire orders table into JSON on every call—millions of characters, hundreds of thousands of tokens. Even a simple query like “status of order ORD-000001?” could blow the context window and cost real money. 👉 Root cause: treating the LLM like a SQL engine over a full table dump (no filtering) 💡 Fix: Parse identifiers (order ID, email, customer ID) Return only matching rows Strip noisy/sensitive fields Hard-cap rows and output size 📉 Result: ~850K+ tokens ➝ ~2K tokens for a comparable successful run ➡️ Back within limits and actually debuggable 🔹 Lab 2 — The “infinite researcher” ReAct + search + read + notes can easily spiral into endless loops: Prompts reward over-thoroughness Content keeps surfacing new URLs No executor stopping conditions 💡 Fix: Convergent system prompt with clear stopping criteria max_iterations + max_execution_time Neutral note-taking tool (no “keep researching” bias) Budget awareness via callbacks 📉 Result: Page reads: 9 ➝ 3 on the same queries 🔹 Lab 3 — MCP tool overload Attaching all 25 tools on every turn added ~2.2K tokens of schema before the user even speaks. 💡 Fix: Middleware layer before the agent Classify query → attach only relevant MCP “server” tools Fallback to full catalog when needed 📉 Result: ~6–11 tools for single-domain queries (instead of 25) ~3× reduction in tool-definition token overhead 🚀 Thread across all three: Bad tools ➝ context explosion Unbounded agents ➝ step explosion Naive routing ➝ per-turn overhead Guardrails, filtering, and routing aren’t optional—they’re part of the product, not an afterthought. Big thanks to Zach Wilson and DataExpert.io for the “break it, then fix it” learning approach—this is exactly what translates to real production debugging. #LangChain #LLM #AIEngineering #Python #AgenticAI #DataExpert

Let’s talk about something fun and interesting I did quite a while ago. I optimized a keyword-driven query system, focusing on improving throughput and stability under constraints. The core problem: Maximize queries/hour while avoiding conflicts, throttling, and system instability. Key optimizations: • Parallel processing with controlled concurrency • Keyword-based query pipeline for structured input distribution • User-agent rotation to distribute request patterns • Retry + backoff mechanisms for handling transient failures • Idempotent execution to avoid duplicate processing One interesting tweak that made a noticeable difference: I introduced a keyword expansion strategy - combining each keyword with incremental alphabet variations (e.g., keyword + a, keyword + b, ...). This helped: • Increase result coverage without changing the core keyword set • Avoid repetitive query patterns • Improve overall discovery efficiency per keyword After multiple iterations, the system stabilized at ~70 leads/hour from about ~15–20 leads/hour with consistent performance. This was one of the most interesting things I had worked on, may not be as flashy but interesting for sure that such a small change can have such a great impact! Curious to know your thoughts! #Optimizations #Python #Software #SaaS