fastapi
OllamaBench
A local LLM benchmarking platform for evaluating and comparing models running through Ollama. It automatically measures: Performance and response latency Quality across reasoning, coding, creative writing, and factual tasks CPU, GPU, and memory usage Multi-model performance comparisons Exportable benchmark reports Everything runs locally with no cloud dependency, keeping benchmark data private. Built with React, TypeScript, FastAPI, Python, SQLite, and Ollama. I built this to answer a practical question: Which local LLM performs best for a specific workload and hardware setup? GitHub: https://github.com/Fortuner47/OllamaBench Would love feedback on the benchmarking methodology and what metrics or evaluation methods I should add next.
Built an AI-Powered Meeting Intelligence Platform - ContextBridge
We've all been in the meeting after the meeting: "Wait, what did we actually decide? Who owns that? Didn't someone raise a risk we never resolved?" ContextBridge reads a raw transcript and automatically pulls out: ◆ Decisions — with owner and a confidence score ○ Action items — with assignee, blockers, and deadlines △ Gaps — the risks nobody flagged out loud (an unowned deadline, an unresolved disagreement) Then it lets you ask questions in plain English across every meeting — like "what's blocking the launch?" and streams the answer back, citing which meetings it came from. Check it out here -- [https://contextbridge.dhruvdeshpande.in/
AI Research Workspace
Most of my earlier projects were built around Express.js for the backend. While working on AI-focused applications, I realized that building serious AI systems requires a different backend ecosystem and a deeper understanding of how AI workflows actually operate. That led me to learn FastAPI, and I used this project to not only learn it, but also polish my backend and AI engineering skills by building something from the ground up. Introducing 🚀 AI Research Workspace (AIRW) — an AI-powered workspace designed to interact with and retrieve information from different types of user data. 🔹 What I explored and implemented: • FastAPI for the backend and API architecture • LangChain & LangGraph for building structured AI workflows and agentic execution • RAG (Retrieval-Augmented Generation) for document-based question answering • Document chunking, embeddings, vector search & hybrid retrieval • Semantic retrieval using embeddings combined with traditional keyword-based retrieval • Query rewriting and retrieval pipelines to improve search quality • MongoDB Atlas Vector Search for storing and retrieving embeddings • Supabase Storage for handling uploaded files and generated content • Groq for LLM-powered generation and reasoning • Tavily for web-based research when web access is enabled • Memory system for retaining useful user-specific information • Tool-based agent execution with planning and execution stages 📚 Supported data & AI capabilities AIRW can work with multiple types of content, including: 📄 PDF documents 📊 CSV & Excel files 🎧 Audio files with transcription and timestamp-based retrieval 🖼️ Images using vision capabilities For documents, the system processes the content into smaller chunks, generates embeddings for those chunks, and stores them for semantic retrieval. When a user asks a question, AIRW retrieves the most relevant chunks. The system can also provide sources, allowing users to see where the information came from 🤖 It isn't limited to document Q&A either. AIRW supports: • Document summarization • Retrieval-based questions • General conversation • Web-assisted research • Memory-based responses • Python-powered analysis and visualization • Excel automation and modification • Multi-step tool execution through an agent workflow One of the things I particularly enjoyed was implementing many of these components myself instead of treating AI frameworks as black boxes. Understanding how chunking, embeddings, retrieval, planning, execution, memory, and tool orchestration work together has been one of the most valuable parts of this project. Github Repo: https://github.com/WaleedImran2007/AI-Research-Workspace Live Demo: https://airw.waleedimran.me Still learning. Still improving. 🚀 AI ArtificialIntelligence AIEngineering GenerativeAI RAG LangChain LangGraph FastAPI Python MongoDB AgenticAI MachineLearning BackendDevelopment FullStackDevelopment
Shipped: An AI Job Matcher Agent — paste a job URL + your resume, get a match score, skill gaps, and a cover letter
Applying for jobs is the same loop every time: read the posting, compare it with your resume, guess your chances, then write a cover letter from scratch. I built an agent that does all of it in one request. Flow: paste a job posting URL → upload your resume PDF → get the analysis back. Output: - match score (0-100) — how well the profile fits the role - skill gaps — what the job asks for that the resume doesn't have - strengths — what actually lines up - cover letter — personalized, ready to send Stack: - FastAPI — async API, two endpoints: /analyze (JSON, local resume path) and /analyze-upload (multipart file upload). Auto Swagger docs at /docs . - OpenAI GPT — the reasoning layer. Single structured prompt, JSON-only output, validated with Pydantic before it ever reaches the response. - httpx + BeautifulSoup — scrapes the job page, pulls the title and hunts for requirement lists (looks for requirements / responsibilities / you will headings, falls back to the first bullet lists on the page). - pdfplumber — page-by-page text extraction from the resume PDF. - Jinja2 + vanilla CSS — drag-and-drop UI, no frontend framework. - Docker — python:3.12-slim , single container, runs anywhere. Two things I'd call out: 1. Graceful degradation. If there's no API key or the LLM call fails, it doesn't 500 — it falls back to a keyword-based scorer that intersects job skills with resume skills and returns a real score. The app is always usable. 2. Scraping is the hard part, not the AI. Every job board renders differently, and half of them are JS-heavy. The heuristic parser works on plain HTML postings but site-specific parsers (LinkedIn, Indeed) are the obvious next step. Next up: semantic matching with embeddings instead of keyword overlap, batch mode for multiple postings at once, and swapping temp-file handling for in-memory PDF parsing. Happy to answer anything about the scraping heuristics or the fallback design. I mostly build AI agents and automation for businesses — chatbots, workflow automation, the boring repetitive stuff that shouldn't be manual. If you're working on something similar, DMs are open. Portfolio: https://danish614.github.io/danish-portfolio/
Shipped: E-Commerce Price Tracker watches Amazon & Daraz, emails you when the price drops
Ever kept refreshing a product page waiting for a sale? I automated that. Paste any Amazon / Daraz product URL + your target price, and it scrapes the live price, stores the history, re-checks every few hours, and emails you the moment it hits your target. What it does - 🔎 Live price scraping (works behind bot protection) - 📉 Full price history per product - ⏰ Auto re-check every few hours (Celery Beat) - 📧 Email alert when target price is hit - 🌐 REST API + Web UI + CLI Tech stack - Backend: Python, FastAPI, Pydantic - Background jobs: Celery + Celery Beat + Redis - DB: PostgreSQL, SQLAlchemy, Alembic migrations - Scraping: Selenium, undetected-chromedriver, BeautifulSoup, cloudscraper - Alerts: SMTP + Jinja2 templates Hardest parts - Anti-bot protection — plain requests gets blocked instantly. Ended up with undetected-chromedriver in headless mode, cloudscraper as a lighter fallback. - HTML keeps changing — Daraz especially. Built multi-selector fallback logic so one broken selector doesn't kill the whole scrape. - Parallel checks — moved from a loop to a Celery task queue so hundreds of products get checked concurrently. - Proper schema — versioned Alembic migrations, not a throwaway script. Same architecture works for competitor price monitoring, stock/availability alerts, or any "watch a site and notify me" automation. 🔗 Code: https://github.com/danish614 🌐 Portfolio: https://lnkd.in/dXE58DgU
Personal Task App: DevPort
I built a control center for all the dev servers on my Windows machine. I keep 40+ repos in one GitHub folder, and I kept losing time to the same questions: which terminal is running what, which port is taken, why did the API die, and what was I supposed to work on next. DevPort puts all of that in one window. What it does - Finds my projects on its own. I pick a folder and it scans for repos, then works out what can run: Vite and Next apps, plain Node servers, FastAPI backends, PowerShell dev scripts. It only reads config files. It never runs repo code to figure things out. - Starts and stops services in order. The backend comes up before the frontend, and it waits for each one to be ready before moving on. - Handles port conflicts. If a port is taken, it shows which process owns it and suggests a free one instead of failing. - Checks health. It uses HTTP or TCP checks, and three failures mark a service as degraded. Optional auto-restart backs off (2s, 5s, 15s), then stops trying. - Keeps logs. You can search, filter and download them. Secrets are redacted before anything is written to disk. - Has a to-do planner built in. It supports subtasks, dependencies, dates and tags, plus a Gantt view that draws the dependency links. It rejects circular dependencies.