Visualize Your Codebase with codegraph-viz

🚀 Built Something Useful for Every Claude Developer While working with Claude Code, I realized one big gap — there’s no clear visibility into usage, tokens, or costs. So I built a solution 👇 🔗 https://lnkd.in/g7kCBnCn 💡 Claude Usage Dashboard A lightweight, local-first tool to track, analyze, and optimize your Claude usage in real-time. ✨ What it does: • Tracks token usage across sessions • Estimates API costs • Provides a clean dashboard + CLI insights • Detects anomalies & suggests optimizations • Includes a budget guard (yes, it can even stop overspending) ⚡ Best part: No setup headache. No dependencies. Just run it with Python. 🧠 Why I built this: When you're building with LLMs, visibility = control. This tool gives you exactly that. If you're working with Claude or exploring AI tools, this might help you 👇 Would love your feedback, ideas, or contributions 🙌 #AI #LLM #Claude #OpenSource #Developers #Python #BuildInPublic #GitHub

🍅 𝐈 𝐣𝐮𝐬𝐭 𝐟𝐢𝐧𝐢𝐬𝐡𝐞𝐝 𝐦𝐲 𝐟𝐢𝐫𝐬𝐭 𝐞𝐯𝐞𝐫 𝐃𝐞𝐞𝐩 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠 𝐩𝐫𝐨𝐣𝐞𝐜𝐭 — and I'm genuinely proud of how it turned out. I built a Tomato Leaf Disease Detection system from scratch using a 𝐜𝐮𝐬𝐭𝐨𝐦 𝐂𝐍𝐍 𝐚𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 in 𝐓𝐞𝐧𝐬𝐨𝐫𝐅𝐥𝐨𝐰/𝐊𝐞𝐫𝐚𝐬. No transfer learning, no pretrained weights — just understanding the fundamentals and building layer by layer. Here's what the project covers: → Custom CNN trained on 10 disease classes (10,000 images) → 84.3% validation accuracy in just 5 epochs → Full data pipeline with normalization, batching & evaluation → Confusion matrix & loss curve analysis → FastAPI backend for real-time inference → Swagger UI for easy endpoint testing 𝐓𝐡𝐞 𝐡𝐚𝐫𝐝𝐞𝐬𝐭 𝐩𝐚𝐫𝐭 𝐰𝐚𝐬𝐧'𝐭 𝐭𝐡𝐞 𝐜𝐨𝐝𝐞 — it was understanding why each architectural decision matters. 𝘞𝘩𝘺 𝘯𝘰𝘳𝘮𝘢𝘭𝘪𝘻𝘦? 𝘞𝘩𝘺 𝘙𝘦𝘓𝘜? 𝘞𝘩𝘺 𝘥𝘰𝘦𝘴 𝘱𝘰𝘰𝘭𝘪𝘯𝘨 𝘴𝘵𝘳𝘪𝘥𝘦 𝘢𝘧𝘧𝘦𝘤𝘵 𝘸𝘩𝘢𝘵 𝘵𝘩𝘦 𝘥𝘦𝘯𝘴𝘦 𝘭𝘢𝘺𝘦𝘳𝘴 𝘢𝘤𝘵𝘶𝘢𝘭𝘭𝘺 𝘴𝘦𝘦? Building it from scratch forced me to answer those questions properly. 𝐍𝐞𝐱𝐭 𝐬𝐭𝐞𝐩𝐬: nail the architecture with proper regularization and tuning, push the accuracy further — then compare it against a fine-tuned EfficientNet to see exactly how much transfer learning gains you. 🔗 GitHub: https://lnkd.in/ge7FeN7Z #DeepLearning #ComputerVision #TensorFlow #MachineLearning #Python #FastAPI

🔍 Showcasing my Friend Suggestion System I previously built an ML-powered friend recommendation system, and I’ve now deployed it to demonstrate how mutual connections and user interactions can be used to generate meaningful friend suggestions. 🔍 How it works: The system analyzes user data such as shared interests, activity patterns, and existing connections. Using similarity-based algorithms, it ranks and recommends relevant profiles. To make the concept more intuitive, I demonstrated the working using a graph-based approach (e.g., Alice → Bob → Charlie → David → Alice), where users are represented as nodes and connections as edges. This allows anyone to simulate and understand the backend process of mutual friend connections. 💡 Key Highlights: • Achieved 88% accuracy in friend recommendations • Improved user engagement by 30% • Delivered 92% user satisfaction in internal testing • Clean and intuitive user interface ⚙️ Tech Stack: Python, C++, HTML, CSS, JavaScript, File Handling,cloud hosting,Graph algorithms. ☁️ Deployment: Deployed on Render, making the system accessible for real-time simulation and better understanding of the recommendation logic. 🎥 Demo Video: In the video below, I demonstrate how the system works using a graph example to simulate real-world friend connections. 🔗 Live Demo:https://lnkd.in/gbXmGTEn 💻 GitHub Repository: https://lnkd.in/gZFNQ9u4 This deployment helped me showcase how recommendation systems and graph-based logic work together in real-world applications. Would love your feedback! 🙌 #MachineLearning #GraphTheory #WebDevelopment #CloudComputing #Render #Python #StudentDeveloper

I recently had a very interesting problem to solve: how to safely store and parse user inputted formulas for our analytics platform. At first glance, it sounds simple. Take a formula, evaluate it, return a number. Something like: (meta.spends + (ads.spends - 50)) * 100 My first instinct was the obvious one: just evaluate the string. That idea lasted about 30 seconds. Because the moment you try to do this in a real system, things get complicated very quickly: • Users can input anything which is a security risk • Formulas need to be reusable and debuggable • Metrics depend on other metrics so ordering matters • You need control over functions and allowed operations I explored existing options, but they were either unsafe (like "eval"), too limited or too heavy for what we needed. I realized we had to build a lightweight execution engine, so here's what we ended up doing: 1. Parse the formula into an Abstract Syntax Tree (AST) 2. Evaluate it in a controlled environment (no arbitrary execution) 3. Extract dependencies to understand which variables are required 4. Support custom functions like SUM, AVG, etc. But the most interesting realization came later. Formulas are not isolated, they form a graph. One metric depends on another, which can depend on another in turn. Suddenly, this becomes a dependency problem. Which means: • You need to resolve execution order • You need to detect cycles • You need to think like a query planner, not just a parser What started as "just evaluate a formula" turned into designing a small, safe, and extensible computation layer. And this is something I have noticed repeatedly. The interesting problems are not always the big ones. They are the ones that look simple enough to ignore, until you try to build them properly. #engineering #systemdesign #python #analytics #backend #softwaredevelopment

Update on my Photo Retrieval Project 🚀 The project is starting to take real shape. In this phase, I implemented a vector database and learned how to perform basic CRUD operations on embeddings. One challenge I noticed was that most of the code was initially AI-generated, which created a disconnect in understanding. To address this, I spent time cleaning up the codebase—simplifying logic, removing unnecessary parts, and restructuring it in a way that made sense to me. This cleanup phase was valuable. It helped me better understand Python, regain ownership of the project, and apply my own methodology. Instead of leaving cleanup for the end, doing it iteratively made the process smoother and easier to manage. Key updates in this phase: • Improved indexing script — now processes only new images and updates embeddings incrementally, avoiding full recomputation • Integrated a vector database for efficient similarity search • Built a REST API using Flask to fetch images matching a query • Added a file-serving route to return images by filename • Refactored the codebase to support real-world datasets instead of being tightly coupled to CIFAR-10 While the system is now capable of handling real-world data, I’m still using the CIFAR dataset for testing. This phase was less about building new features and more about understanding, refining, and making the system scalable. More updates soon. If you’d like to follow along, here’s the repo: https://lnkd.in/dUEzpxX8

 Bridging the gap between Machine Learning and Production: An Uncertainty-Aware Forecasting System 🌤️ Most weather apps give you a single deterministic number. But in the real world, data is rarely 100% certain. I’ve spent the last few weeks building a weather forecasting system that doesn't just predict the temperature—it communicates confidence ranges and handles real-time environmental data. Key Engineering Highlights: 🔹 Machine Learning: Uses an XGBoost Regressor for recursive 7-day forecasting, with dynamic uncertainty calibration (95% confidence intervals). 🔹 Live Data Anchoring: Integrated the Open-Meteo API to ensure forecasts are anchored to real-world "Day 0" conditions. 🔹 Modern Stack: Built a decoupled architecture using FastAPI (Python) for the logic and React + Tailwind CSS for a premium, dark-mode UI. 🔹 DevOps & Deployment: Fully containerized using Docker & Docker Compose for seamless environment management. Moving from monolithic Python scripts to a modern, containerized Full-Stack architecture was a massive learning experience in system design and dependency management. Check out the full source code and documentation in the comments below! 👇 #MachineLearning #ReactJS #Python #FastAPI #Docker #FullStack #BuildingInPublic #CSStudent #DataScience

Refactoring a complex codebase is usually a guessing game. Standard linters will catch your syntax errors, but they completely miss the silent architectural drift, hidden coupling, and "God modules" that quietly suffocate your project over time. To fix this, I just released the 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲-𝗮𝘂𝗱𝗶𝘁 skill for my 𝗺𝗮𝗱-𝘀𝗰𝗶𝗲𝗻𝘁𝗶𝘀𝘁-𝘀𝗸𝗶𝗹𝗹𝘀 Claude Code plugin. It’s a 10-phase structural audit that turns unpredictable refactoring into a precise, systematic process. Unlike generic code reviewers, this skill grounds its findings in established methodologies: Hexagonal Architecture, Domain-Driven Design (DDD), SOLID, and the Twelve-Factor App. But the real magic is its core principle: 𝗷𝘂𝗱𝗴𝗺𝗲𝗻𝘁 𝗼𝘃𝗲𝗿 𝗽𝗿𝗲𝘀𝗰𝗿𝗶𝗽𝘁𝗶𝗼𝗻. It understands that a structural choice (like mixing computation and I/O) that is an anti-pattern in a business app might be the exact right approach in a data pipeline. It looks for concrete harm, not just rule-following. I used it to drive a massive refactor of the Luxury Lakehouse. The audit surfaced 56 specific findings, giving Claude the exact context needed to execute the refactor predictably. The results from a single feature branch: 🔍 𝗜𝗻𝘀𝘁𝗿𝘂𝗺𝗲𝗻𝘁𝗲𝗱 𝟭𝟭 "𝗿𝗼𝗴𝘂𝗲" 𝗶𝗻𝗴𝗲𝘀𝘁𝗶𝗼𝗻 𝗺𝗼𝗱𝘂𝗹𝗲𝘀 that had been operating entirely outside the system's lifecycle and cost-tracking boundaries. 🏗️ 𝗦𝗽𝗹𝗶𝘁 𝟳 𝗺𝗮𝘀𝘀𝗶𝘃𝗲 "𝗚𝗼𝗱 𝗺𝗼𝗱𝘂𝗹𝗲𝘀" (each >800 lines) into focused, single-responsibility components. 🔄 𝗘𝗹𝗶𝗺𝗶𝗻𝗮𝘁𝗲𝗱 ~𝟮,𝟰𝟬𝟬 𝗹𝗶𝗻𝗲𝘀 𝗼𝗳 𝗰𝗿𝗼𝘀𝘀-𝗱𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁 𝗱𝘂𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻 between the Python wheel and the Docker image. 🔒 𝗘𝘅𝘁𝗿𝗮𝗰𝘁𝗲𝗱 ~𝟭𝟬𝟬 𝘂𝗻𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗲𝗱 𝗦𝗤𝗟 𝗾𝘂𝗲𝗿𝘆 𝘀𝘁𝗿𝗶𝗻𝗴𝘀 scattered across 14 UI state modules into a dedicated, clean data access layer. 🛡️ 𝗜𝗺𝗽𝗹𝗲𝗺𝗲𝗻𝘁𝗲𝗱 𝘀𝘁𝗿𝗶𝗰𝘁 𝗖𝗜 𝗰𝗼𝗻𝘁𝗿𝗮𝗰𝘁𝘀 to enforce dependency direction, ensuring the architecture doesn't just decay again next month. If you want to keep your codebase structurally sound as it scales, check out the new skill in the repository: https://lnkd.in/eGyUbAZe #SoftwareArchitecture #Refactoring #DomainDrivenDesign #CleanArchitecture #ClaudeCode #AI #DataEngineering #Python

🚀 Visualizing code like a system, not just files When working with large codebases, the hardest part isn’t writing code, it’s understanding how everything connects. So I built an AI Codebase Knowledge Graph. 💡 What it does • Transforms an entire codebase into an interactive knowledge graph • Maps relationships between functions, classes, and modules • Helps visualize dependencies and architecture in a clear, intuitive way • Enables impact analysis by tracing how changes affect other parts of the system ⚙️ How it works I built an AST-based parsing pipeline to extract structural elements from Python code, then used graph modeling to represent relationships across the codebase. Using NetworkX, the system constructs a graph of dependencies, and a Streamlit interface lets you explore it interactively. 📊 Why it matters Instead of digging through files manually, you can see your system as a connected structure. This makes it much easier to: • Understand complex architectures • Debug faster • Analyze the impact of changes before making them 🧠 The idea I wanted to move beyond code as text and treat it as a system of relationships. 🔗 GitHub https://lnkd.in/gqBkRDn9 #AI #GraphAnalytics #DeveloperTools #Python #CodeVisualization #SoftwareEngineering

📣 SynapseKit v1.4.7 + v1.4.8 just dropped. Back to back. Huge thanks to Dhruv Garg and Abhay Krishna who drove most of this sprint. 🙌 Two themes in these releases: getting data in, and making workflows resilient. Getting data in: 5 new loaders The gap between "I have a RAG pipeline" and "I can actually feed it my company's data" is a loader problem. These close it: 📨 SlackLoader — pull channel messages directly into your pipeline 📝 NotionLoader — ingest pages and databases from Notion 📖 WikipediaLoader — single article or multiple, pipe-separated 📄 ArXivLoader — search arXiv, download PDFs, extract text automatically 📧 EmailLoader — any IMAP mailbox, stdlib only, zero extra dependencies SynapseKit now has 24 loaders. Your data is probably already covered. Better retrieval — ColBERT ColBERTRetriever brings late-interaction ColBERT via RAGatouille. Instead of comparing a single query vector against a single document vector, ColBERT scores every query token against every document token (MaxSim). On long documents the recall improvement is significant- single-vector approaches lose detail in the compression. Token-level scoring doesn't. Resilient graph workflows Subgraph error handling now ships with three strategies — retry with backoff, fallback to an alternative graph, skip and continue. Production workflows break. The question is whether they break gracefully. Where SynapseKit stands today: 27 providers · 9 vector backends · 42 tools · 24 loaders · 2 hard dependencies ⚡ pip install synapsekit==1.4.8 📖 https://lnkd.in/dvr6Nyhx 🔗 https://lnkd.in/d2fGSPkX #Python #LLM #RAG #AI #OpenSource #MachineLearning #Agents #SynapseKit

Spending some time deep in architecture decisions for a side project, and honestly, this is the part I love most. The stack is taking shape: 🔹 FastAPI + Python on the backend 🔹 React + Vite on the frontend 🔹 PostgreSQL with pgvector for semantic search 🔹 LlamaIndex for the RAG pipeline 🔹 Anthropic + OpenAI APIs for generation The domain is healthcare-adjacent. I'm keeping the specifics close to the chest for now, but the core challenge is interesting: how do you build a system that retrieves clinically relevant evidence, reranks it, and generates structured recommendations that a practitioner can actually trust and trace back to sources? Some of the design decisions I've been enjoying: • Separating QueryBuilder, VectorRetriever, Reranker, and PlanGenerator into composable pipeline stages • A human-in-the-loop approval flow before any recommendation goes live • Audit trails baked in from day one, not bolted on later Still a lot of road ahead, but it's the kind of project that makes you a better engineer regardless of where it lands. Building in public (ish). Happy to geek out with anyone working on RAG systems or clinical AI. 🙌 #RAG #FastAPI #pgvector #LLM #Python #AIEngineering #BuildingInPublic