Ziv - Local Semantic Search for Python Codebases

DAY 5 - THE TECH STACK (Tools & Why I Chose Them) Every tool in my stack was a deliberate choice. Here's why - and what I'd tell my past self about each one. No random picks. No "I've always used this." Every decision had a reason. > Python :Primary language for the crawler and extraction logic. Chose it for its rich ecosystem - BeautifulSoup, Playwright, asyncio - nothing else comes close for this use case. Wish I knew: Async Python has footguns. Mixing sync and async code will ruin your day silently. > Playwright (Headless Browser) : Handles JS-rendered pages that raw HTTP requests miss completely. Chose it over Puppeteer for Python-native support and better async handling. Wish I knew: Resource usage adds up fast at scale. Spin up only what you need. > Message Queue (e.g., Redis / RabbitMQ) : Acts as the backbone between crawlers and processors - total decoupling. Chose it because I needed workers to fail independently without cascading crashes. Wish I knew: Queue monitoring is not optional. A silent backlog will sneak up on you. > Database (Structured Storage) : Stores normalized technographic profiles per company, queryable and enriched. Chose a relational model to keep tech profiles structured and joinable. Wish I knew: Schema design early saves migrations later. Do not skip this. > Docker: Containerized each service so workers can be spun up and torn down without friction. Chose it for portability and reproducibility across environments. Wish I knew: Docker networking between containers is its own learning curve. Start simple. Which tool here are you most curious about? Happy to go deeper on any of them 👇 #TechStack #Python #DistributedSystems #WebScraping #BackendDevelopment

📣 12,000 downloads. We shipped the first release 6 weeks ago. No launch event. No press. No paid promotion. Just engineers who found it, tried it, and kept using it. And 17 contributors who decided to build instead of wait. Here's what 12,000 downloads actually built: 33 LLM providers behind one interface. 45 agent tools. 46 document loaders. 20 retrieval strategies. 9 vector store backends. MCP client and server. Built-in RAG evaluation. OpenTelemetry observability. Production guardrails. EvalCI for quality gates in CI. Fully local RAG with GPT4All and vLLM. 2 hard dependencies. Async-native from day one. Apache 2.0. To every engineer who pip installed, opened an issue, sent a message, or pushed a PR: this is yours too. The door is still open. Many issues waiting. Good first issues stocked. PR reviews fast. ⭐ https://lnkd.in/d2fGSPkX #OpenSource #Python #LLM #AI #RAG #BuildInPublic #MachineLearning #SynapseKit

📣 We've run 22 benchmarks comparing LangChain, LlamaIndex, and SynapseKit across cold start, dependencies, lines of code, RAM, chunking, BM25, hybrid search, memory, async throughput, and more. Every number is reproducible. Every notebook is public on Kaggle. Fork and run yourself. Week 3 starts next week. Agents, tool calling, multi-agent orchestration. The scorecard is about to get interesting. engineersofai.com #Python #LLM #RAG #AI #EngineersOfAI #SynapseKit

𝗦𝘁𝗼𝗽 𝗯𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗲𝘃𝗲𝗿𝘆 𝗯𝗮𝗰𝗸𝗲𝗻𝗱 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲 𝘄𝗮𝘆. FastAPI isn't just "another Python framework." It's a deliberate choice — and knowing when to reach for it matters more than knowing how to use it. 𝗣𝗶𝗰𝗸 𝗙𝗮𝘀𝘁𝗔𝗣𝗜 𝘄𝗵𝗲𝗻:  • You're building ML/AI-powered APIs and your team already lives in Python  • You need async performance without the boilerplate of Go or Java  • Auto-generated docs (Swagger/OpenAPI) aren't a nice-to-have — they're a requirement  • You want type safety that actually catches bugs before production 𝗦𝘁𝗶𝗰𝗸 𝘄𝗶𝘁𝗵 𝘁𝗿𝗮𝗱𝗶𝘁𝗶𝗼𝗻𝗮𝗹 𝗯𝗮𝗰𝗸𝗲𝗻𝗱𝘀 (𝗦𝗽𝗿𝗶𝗻𝗴, 𝗗𝗷𝗮𝗻𝗴𝗼, 𝗘𝘅𝗽𝗿𝗲𝘀𝘀, .𝗡𝗘𝗧) 𝘄𝗵𝗲𝗻:  • Your org already has deep expertise and infra around them  • You need battle-tested ORM support and a massive plugin ecosystem  • You're building monoliths where convention-over-configuration saves months 𝗧𝗵𝗲 𝗿𝗲𝗮𝗹 𝗮𝗻𝘀𝘄𝗲𝗿? 𝗜𝘁'𝘀 𝗻𝗲𝘃𝗲𝗿 𝗮𝗯𝗼𝘂𝘁 𝘁𝗵𝗲 𝗳𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸. 𝗜𝘁'𝘀 𝗮𝗯𝗼𝘂𝘁 𝘁𝗵𝗲 𝗽𝗿𝗼𝗯𝗹𝗲𝗺. FastAPI shines where speed-to-deploy, async I/O, and Python-native ML pipelines intersect. Forcing it into a legacy enterprise CRUD app is like using a scalpel to chop wood. Choose your tools like an engineer, not a fan. Thoughts? When did FastAPI click (or not click) for you? #FastAPI #Python #BackendDevelopment #SoftwareEngineering #WebDevelopment #APIDevelopment #TechCommunity #Programming #MLOps #SystemDesign

One instruction file doesn't scale. The moment your codebase has a Python service and a TypeScript frontend and a Go worker, a single CLAUDE.md becomes either too generic to be useful or too bloated to trust. Scoped context solves this the way filesystems already do — by nesting. Org-level rules wrap user-level rules wrap project-level rules wrap directory-level rules. The agent reads whichever scope it's working inside, the same way a developer picks up conventions walking into a new folder. Example: the org says "never commit .env files." The project says "use Zod for validation." The ./src/api/ directory says "return JSON, validate schema." The agent sees all three, cleanly composed. The trade-off is discoverability. When rules live in four places, it's harder to answer "what does the agent actually see right now?" Good tooling here isn't optional — it's the whole pattern. Treat context as a tree, not a file. How are you organizing rules across a multi-language codebase? #AI #AgenticAI #SoftwareArchitecture #DeveloperTools #Clausey

I searched my Claude Code session history and found something I didn't expect. Here's what I found: https://lnkd.in/dFcHWNGS 185 sessions in 13 days. 1,501 commands. 94+ commits shipped. Only 3 references to an IDE — and two were about window management. I'm an EM who codes daily. Java, Python, Kubernetes, Helm,  infrastructure-as-code across multiple repos. The kind of stack  that should demand a heavyweight IDE. Instead, I've been shipping from a terminal. And the work has  never moved faster. I wrote about why the IDE's core value proposition — "we'll help  you find and edit text in files" — feels increasingly like a card  catalog in the age of Google. The shift from file navigation to intent-driven development  already happened. Most of us just haven't checked our own  session history yet. #SoftwareEngineering #AI #DeveloperTools #EngineeringManagement

17k GitHub stars in days. For a Python CLI. Here's why that number makes sense. Your AI agent can search the web, but can it?. Ask it to check a tweet, read a Reddit thread, or pull a YouTube transcript, and it just can't. It's not a knowledge problem. These platforms actively block agent access. They gate, they break, they serve garbage.The agent is smart but completely blind to anything living on a platform. Someone created, agent reach. Agent-Reach gives your agent direct access to X, Reddit, YouTube, GitHub, and any RSS feed. No paid APIs, no subscriptions, simple to set it up. A gap I can resonate with, and so can several other people. Link to the project in comments.

Day 7 - I built a live Weather API in Python. It runs for free. Forever. ⠀ 🚀TechFromZero Series - FastAPIFromZero ⠀ This isn't a Hello World. It's a real async REST API with a cloud database: 📐 OpenWeather → FastAPI (Render) → motor → MongoDB Atlas (free) ⠀ 🌐 Try it live: https://lnkd.in/dfrggisJ ⠀ 🔗 The full code (with step-by-step commits you can follow): https://lnkd.in/d8S2AmcP ⠀ 🧱 What I built (step by step): 1️⃣ Project scaffold — venv, requirements.txt, .env.example 2️⃣ FastAPI app — CORS, lifespan hook, health check endpoint 3️⃣ Async MongoDB connection — motor client, shared connection pool 4️⃣ Pydantic schemas — auto-validate input, auto-generate Swagger docs 5️⃣ OpenWeatherMap client — async httpx fetch, clean error handling 6️⃣ Weather endpoints — POST /weather, GET /weather, filter by city, delete, aggregation stats 7️⃣ Render deploy config — render.yaml, $PORT, env vars as code 8️⃣ README — full beginner guide with architecture diagram ⠀ 💡 Every file has detailed comments explaining WHY, not just what. Written for any beginner who wants to learn FastAPI by reading real code — with full clarity on each step. ⠀ 👉 If you're a beginner learning FastAPI, clone it and read the commits one by one. Each commit = one concept. Each file = one lesson. Built from scratch, so nothing is hidden. ⠀ 🔥 This is Day 7 of a 50-day series. A new technology every day. Follow along! ⠀ 🌐 See all days: https://lnkd.in/dhDN6Z3F ⠀ #TechFromZero #Day7 #FastAPI #Python #MongoDB #MongoDBAtlas #Render #AsyncPython #LearnByDoing #OpenSource #BeginnerGuide #100DaysOfCode #CodingFromScratch

Built a small open source tool this week: cc-tokens — a Claude Code slash command that shows your token usage, cost breakdown, and context window stats without leaving your terminal. Type /tokens inside any Claude Code session. That's the whole UX. What it shows: → Input / output / cache write / cache read tokens → Estimated API cost + how much prompt caching saved you → Context window % used (with a visual bar) → Multi-session views: --all for today, --week for 7 days → --json output for scripting Why I built it: Claude Code already has /usage, but it doesn't show per-model cost breakdown when you switch models mid-session, doesn't show cache savings, and has no cross-session view. The interesting engineering bit: Claude Code's JSONL logs have a known accuracy problem — usage.input_tokens is a streaming placeholder (75% of entries = 1, never updated). The tool handles this by deduplicating on message ID and reading from the last main-chain entry. Cache fields write correctly from the start, so those are reliable. The README is honest about what's approximate and what isn't. Zero dependencies. Pure Python stdlib. Installs in 30 seconds. https://lnkd.in/exeHeXnf #ClaudeCode #Anthropic #DeveloperTools #OpenSource #AI

Production-ready multi-agent orchestration is finally here. With Agent Framework v1.0 introducing some exciting new features. My personal favourites: 1. Agent workflows 2. Middleware hooks 3. Integration with managed agents in Foundry Agent Service 4. Multi-agent orchestration with HITL 5. Skills 6. Foundry Tools, Memory, Observability and Evaluations and many more. Check out the amazing blog post from Shawn Henry detailing the various features with concrete examples in Python and .NET https://lnkd.in/dKBRDujY