# Siddhi Kale > Full-stack and AI engineer based in Pune, India. Siddhi Kale is a full-stack and AI engineer in Pune. TechVerse 2026 First Prize winner, Rank 7 at the Shinchan Online Hackathon 2026, first author of a published research paper (Springer Nature). Builds AI agents, data dashboards and live web apps such as Ritam and ClaimMate. Open to: Internships, Full-time roles, Freelance projects, Collaborations. ## Contact - Email: siddhi.kale2503@gmail.com - Phone: +91 85301 82828 - GitHub: https://github.com/siddhi-works - LinkedIn: https://www.linkedin.com/in/siddhikale25/ - Website: https://siddhi-kale.vercel.app/ - Resume (PDF): https://siddhi-kale.vercel.app/media/resumes/ai-ml-data-science.pdf ## About I’m a full-stack and AI engineer who builds, automates and evolves. I don’t just solve a problem; I look for the most efficient way to solve it. I lead, I take responsibility, I work smart and I love what I do. If I make mistakes, I learn from them, which is why I’m not rigid: I adapt and evolve. I build the whole thing: the model, the API and the interface, on LangGraph, Gemini, React, TypeScript, Node.js and Python. Each project is built to run for real users, not just a demo. - Based in: Pune, India - Education: BTech in Artificial Intelligence and Data Science (final year), Ajeenkya DY Patil University, Pune - Languages: English, Hindi, Marathi ## Experience - Aug 2026 – Oct 2026: Data Science Intern, Aabhak Impex Pvt. Ltd.. Analysed sales and inventory data with Python and Pandas to find business trends. Ran exploratory analysis on monthly sales patterns and product demand. Built a basic sales forecasting model with Linear Regression and charted the results with Matplotlib. - Apr 2025 – Nov 2025: Content Editor and Management Coordinator, Abhivyakti Editorial Team, ADYPU. Ran the content calendar across 5 platforms. Engagement up 25% year over year, errors down 15%, production efficiency up 30%. - Sep 2024 – Present: Research Volunteer, NSS, ADYPU. Supported 8 youth programmes reaching 100+ children a year. - Nov 2021 – Mar 2023: Content and Marketing Volunteer, Bindu Non-Profit Organisation. Led 5 creators. Content output up 25%, organic traffic up 15%, lead generation up 10%. ## Achievements - TechVerse 2026: First Prize. I led Team Moleculens to first place at Ajeenkya DY Patil University with Chicago Crime Analytics: 1.05 million crime records turned into a dashboard anyone can question. - Shinchan Online Hackathon 2026: Rank 7. Ritam: a banking assistant that checks what an Indian bank tells you and helps you get errors fixed. Built in 24 hours. - Smart India Hackathon 2026: Internal winner. BhuSamhita: one trusted layer across land records, GIS, courts, tax and payment. I built its backend and every integration. - Research paper, international conference: Published paper. Co-authored a machine learning paper on spotting coordinated bot accounts. Presented at an international AI conference (ICAIML-AE 2026) and published by Atlantis Press, part of Springer Nature. ## Publication Hybrid Feature-Based Comparative Analysis of Supervised and Unsupervised ML-Based Intelligent Bot Detection Model for Social Media Data. ICAIML-AE 2026, Atlantis Press, Springer Nature. International Conference on Artificial Intelligence and Machine Learning for Agro-Ecosystems, organised by Vishwakarma University in collaboration with Binghamton University, USA. ## Skills - Languages: Python, R, SQL, TypeScript - AI and ML: TensorFlow, Keras, scikit-learn, OpenCV, NLTK, NumPy, pandas - Agents, LLMs and solvers: LangGraph, LangChain, MCP, Gemini API, OR-Tools, Z3 - Web and data: React, Next.js, Node.js, Express, FastAPI, Flask, Streamlit, REST APIs, PostgreSQL, SQLite, MySQL, Docker, GitHub Actions - Core concepts: Machine learning, Deep learning, Natural language processing, Generative AI, Large language models, Agentic AI - Engineering: API design, Data structures and algorithms, Database management, Git and GitHub, CI/CD with GitHub Actions, Deployment on Vercel - Working style: Problem solving, Analytical thinking, Teamwork, Communication, Leadership - R tooling: ## Projects ### Bot Detection in R A Random Forest model that separates bots from real accounts by reading what they post and how they behave. 90% accuracy on about 10,000 held-out accounts. Published at ICAIML-AE 2026. - Recognition: Published research paper - Built for: ICAIML-AE 2026, where the paper was published by Atlantis Press (Springer Nature) - Team: With Akriti Biswas, guided by Dr. Vishal Shirsath - When: 2026 - Tech stack: R, ranger, caret, text2vec, tidyverse, ggplot2, pROC - 90% accuracy on held-out accounts - 4,184 bots caught - 179 real accounts wrongly flagged - [Case study](https://siddhi-kale.vercel.app/work/bot-detection/) - [GitHub](https://github.com/siddhi-works/socialmedia-bot-detection-using-R) - [LinkedIn post](https://www.linkedin.com/posts/siddhikale25_machinelearning-artificialintelligence-datascience-ugcPost-7473658377227624448-6KJW/) **Problem** Bot accounts are no longer easy to spot. Many of them post ordinary sentences and look like any other profile. What gives them away is the pattern: how often they mention other accounts, how their engagement compares with the number of followers they have, and the promotional phrases they repeat. A detector that only reads text misses the behaviour, and one that only counts activity misses the language. The question behind this project was whether the two signals together separate bots from real people reliably enough to be useful as a backend layer for a platform. **Solution** I built the detector end to end in R. Behavioural features are engineered first: log-scaled follower counts, engagement and mention ratios, retweet and mention counts and the verified flag. Tweet text is cleaned, tokenised and turned into TF-IDF features with text2vec, keeping only terms that appear often enough to matter and not so often that they carry no signal. Both feature sets are joined and fed to a Random Forest built with ranger (300 trees, mtry set to the square root of the feature count). The data is split 80/20 with caret so the evaluation is on accounts the model has never seen, and the same script produces the confusion matrix, ROC curve and the precision, recall and F1 charts that sit in the repository. **How it was built** About 60% of the effort went into preparing the data, around 35% into testing different approaches, and the remaining 5% into debugging, visualisation and documentation. The repository also contains the data-preparation step in full, including the part that adjusts counts and adds phrases for a 65% sample of records, so the way the dataset was shaped can be inspected. Supervised models beat unsupervised ones, and combining behavioural and text features beat using either alone. The takeaway: understanding the data pays off more than trying another algorithm. **Result** On roughly 10,000 held-out accounts the model reaches 90.0% accuracy. It correctly flagged 4,184 bots and cleared 4,817 real accounts, with 179 real accounts wrongly flagged and 819 bots missed. The work was written up with co-author Akriti Biswas and faculty advisor Dr. Vishal Shirsath and published at ICAIML-AE 2026. **How it works** 1. Data: A labelled set of social media accounts with their tweets and activity counts 1. Behaviour: Log follower count, retweets, mentions, engagement ratio, mention ratio and verified status 1. Text: TF-IDF features built with text2vec from the words accounts use 1. Model: A Random Forest in ranger with 300 trees, trained on 80% of the data 1. Check: Confusion matrix, ROC curve, precision, recall and F1 on the other 20% ### Chicago Crime Analytics A dashboard that turns 1,048,575 crime reports into 8 KPIs, 10 charts and a district map, with an assistant called Detective Dot and a page that shows exactly how the data was cleaned. - Recognition: TechVerse 2026 First Prize - Built for: TechVerse 2026 at Ajeenkya DY Patil University, Pune - Team: Team Moleculens - When: 2026 - Tech stack: Python, pandas, React, TypeScript, Vite, d3, Vercel - 1.05M crime reports analysed - 8 KPIs - 10 charts - [Case study](https://siddhi-kale.vercel.app/work/chicago-crime/) - [Live app](https://chicago-crime-data-analytics.vercel.app) - [GitHub](https://github.com/siddhi-works/ChicagoCrime-DataAnalytics) **Problem** The organisers of TechVerse supplied an extract of the City of Chicago crime data: more than a million police reports with 22 columns, mixed types, swapped dates and large gaps in the coordinates. The brief was to turn it into something a person could actually read, with a fixed set of KPIs and charts. The risk with data this size is a dashboard that looks convincing but hides how much has been cleaned, inferred or left out. We wanted the numbers to be both easy to read and easy to question. **Solution** We built an interactive dashboard in React and TypeScript on top of an analysis done in Python. All 8 KPIs and 10 required charts sit on one page, and four filters (crime type, district, arrest and domestic) update every number at once. A Story view writes the findings as short chapters, for example that summer has 17% more crime per day than winter and weekend nights run 69% above weekday nights. A district map shows about 2,400 patches coloured by police district with a panel for totals, top crime types and arrest rate against expectation. Detective Dot, the built-in assistant, answers questions from the project’s own analysis and recalculates live on the filtered data. **How it was built** A Fair Arrest analysis adjusts arrest rates for crime type, which shows that 86% of the gap between evening and night comes from what was reported rather than the time of day. The Data Trust page lists every cleaning step, metric definition, method and limitation in one place, including that 31% of coordinates are missing and that no rows were removed. Charts are hand-built in SVG and Canvas with d3 for scales and shapes, with Motion for animation, and the whole dashboard is deployed on Vercel. **Result** The project took First Prize at TechVerse 2026 at Ajeenkya DY Patil University, with me leading Team Moleculens. The live dashboard is open for anyone to filter and question. **How it works** 1. Source: 1,048,575 records, 22 columns, 33 crime types and 24 districts from 2001 to 2026 1. Clean: 424,638 swapped dates repaired and no rows deleted, with every step logged 1. Summary: 8 KPIs: 20.5% arrest rate, 18.3% domestic, 17.7% at night and 29.2% violent 1. Explore: 10 charts, four filters and a map of about 2,400 patches coloured by district 1. Ask: Detective Dot answers from the project’s own analysis and recalculates on the filtered data ### ARIA Automated Research and Intelligence Agent. Searches arXiv, reads the papers, finds gaps and writes a publication-style LaTeX paper that exports as a PDF. - Built for: Researchers, students and anyone who needs to get from a topic to a first structured draft - When: June to August 2026 - Tech stack: LangGraph, LangChain, Gemini 2.5 Flash, arXiv API, PyPDF2, LaTeX, Tectonic, Streamlit - arXiv in - LaTeX draft - PDF out - [Case study](https://siddhi-kale.vercel.app/work/aria/) - [GitHub](https://github.com/siddhi-works/ARIA) - [LinkedIn post](https://www.linkedin.com/posts/siddhikale25_artificialintelligence-generativeai-aiagents-ugcPost-7489367890979098624-xYlM/) **Problem** Research is rarely limited by access to papers. It is limited by the time it takes to find the relevant ones, read them, compare them and turn what you learned into a structured document. For a student starting on a new topic that can be weeks of work before there is a first draft. Search engines retrieve. They do not read across papers, notice what is missing, or produce a document. ARIA was built to close that gap between finding information and creating knowledge. **Solution** ARIA is an agent built on LangGraph and LangChain with Google Gemini 2.5 Flash as the model. It has three tools: an arXiv search tool, a PDF analysis tool and a PDF rendering tool. The agent decides which tool to call next in a loop, so a single request like “write a research paper on prompt engineering” becomes a sequence of searching, reading, synthesising and writing. The output is not a text blob. The paper is generated as LaTeX with proper sections and mathematical formulations, compiled with Tectonic and delivered as a downloadable PDF from a Streamlit chat interface, with session memory kept by LangGraph so the conversation can continue. **How it was built** The code is split by responsibility: the agent graph and tool orchestration, the arXiv client, the PDF reader that prepares text for analysis, the LaTeX and PDF builder, and the Streamlit front end. Dependencies are managed with uv and the project runs on Python 3.11 or newer. The README is explicit that generated papers must be reviewed and cited properly before any academic use. The roadmap includes a vector database, research knowledge graphs and IEEE and ACM formatting. **Result** Topic in, finished paper out: a working research assistant, shared publicly on LinkedIn with the source open on GitHub. **How it works** 1. Discover: Searches arXiv for recent papers on a topic and returns metadata and PDF links 1. Analyse: Downloads the PDFs, extracts the text and summarises findings, limitations and future work 1. Ideate: Identifies research gaps and proposes directions that are not yet covered 1. Write: Drafts a complete paper: abstract, introduction, literature review, methodology, results and references 1. Deliver: Compiles the LaTeX with Tectonic and offers the PDF for download ### BhuSamhita One parcel, one ULPIN, every connected land record. A single layer across the separate land systems of Maharashtra, Uttar Pradesh and Gujarat, with GIS, validation and four languages. Winner of the Smart India Hackathon internal round. - Recognition: Smart India Hackathon internal winner - Built for: Smart India Hackathon, internal round - Team: AIgniters - When: 2026 - Tech stack: Python, FastAPI, React, GIS, GeoJSON, SQLite, REST APIs, ULPIN, RBAC, Anthropic API - 3 states - 4 languages - SIH Smart India Hackathon internal winner - [Case study](https://siddhi-kale.vercel.app/work/bhusamhita/) - [GitHub](https://github.com/siddhi-works/BhuSamhita) - [Demo video](https://youtu.be/CldL2wF95Po) - [LinkedIn post](https://www.linkedin.com/posts/siddhikale25_sih2026-smartindiahackathon-sih-ugcPost-7516230406061400064-cw8e/) **Problem** Land records in India sit in separate systems for the land record itself, registration, mutation, planning, tax and utilities, and every state organises them differently. A citizen who wants to confirm a parcel has to visit several portals that disagree on format, language and sometimes on the facts. Replacing those systems is not realistic. The problem the hackathon asked us to solve was how to let them speak to each other without forcing every state to rebuild. **Solution** BhuSamhita is an integrated, GIS-based digital infrastructure for land governance: one parcel, one ULPIN (Unique Land Parcel Identification Number), every connected land record. It federates instead of replacing. A canonical land model sits in the middle, and state adapters for Maharashtra, Uttar Pradesh and Gujarat translate each state’s records into it. Parcels are identified through a ULPIN-based registry, so the same plot can be traced across land records, registration, mutation, planning, tax and utility data. On top of that sit Unified Land Profiles that bring land records, registration, mutation, land use and encumbrance together for one parcel, GIS-based parcel visualisation, and a cross-record validation engine that surfaces actionable data-quality findings for government officers. Two portals use it: a citizen portal and a government officer portal with parcel search, e-services, analytics, role-based access and audit trails. The interface runs in English, Hindi, Marathi and Gujarati. **How it was built** I built everything except the frontend: the integrations that connect three states’ land systems, and the Python backend behind them. That covers the state adapters, the canonical land model, the ULPIN parcel registry, the validation engine, glossary and translation, analytics and workflow, role-based access and the audit trail. Tests cover normalisation, validation, immutability, GIS and the API. An optional AI assistant, built on the Anthropic API, uses the selected parcel’s records and validation findings as its context. All data in the demo is replicated government-system data used for demonstration only. **Result** BhuSamhita won the internal round of the Smart India Hackathon (SIH) at Ajeenkya DY Patil University. **How it works** 1. Adapters: One adapter each for Maharashtra, Uttar Pradesh and Gujarat keeps every state’s own data structure 1. Model: A canonical land model gives every source the same shape 1. Identity: ULPIN-based parcel registry so a plot is the same plot everywhere 1. Verify: A validation engine cross-checks sources and flags data-quality problems 1. Serve: A citizen portal and state-specific government workflows with mutation and verification reports ### ClaimMate A claim companion for Indian insurance in English and Hindi. Four specialised agents and a supervisor turn a claim into what is missing, who must act and what happens next. - Built for: HackDeVengers 1.0, organised by Devengers - Team: Solo, in one day - When: August 2026 - Tech stack: Gemini, React, TypeScript, Vite, Node.js, Express, Render - 4 specialised agents - 2 languages: English, Hindi - Live on Render - [Case study](https://siddhi-kale.vercel.app/work/claimmate/) - [Live app](https://claimmate.onrender.com) - [GitHub](https://github.com/siddhi-works/ClaimMate) - [LinkedIn post](https://www.linkedin.com/posts/siddhikale25_hackdevengers-agenticai-generativeai-ugcPost-7496140159357415424-aLyO/) **Problem** People file insurance claims at the worst moments: after an accident, during a hospital stay, under financial stress. The insurer’s portal tells them which document to upload. It does not explain what is wrong, who has to act or what happens afterwards. The problem statement arrived at the start of the day, and I took on the gap between a process built to handle claims and a person who needs to know what to do next. **Solution** ClaimMate splits a claim across four specialised agents instead of asking one language model to do everything: a Policy agent, a Claim agent, a Document agent and an Audit agent. A Supervisor turns their outputs into a single plan: what is happening, what is missing, who needs to act, what to do now and what happens next. The assistant remembers the context of the same claim, so follow-up questions in the Doubt section are answered from the actual claim rather than from scratch. A Claim Stuck flow explains why progress may be blocked and points to the right escalation route. The interface works in English and Hindi, and the roadmap adds more Indian languages. **How it was built** The backend extracts text from PDFs, validates the structured output from Gemini, applies timeouts and error handling, and falls back to deterministic responses when the model is unavailable. The Gemini credentials stay on the server behind an Express API. The front end is React, TypeScript and Vite, deployed on Render. The project states plainly that it gives informational guidance and does not guarantee approval or replace the insurer, a lawyer or the regulator. **Result** Live on Render, and built from problem statement to deployment in a single day at HackDeVengers 1.0. **How it works** 1. Policy agent: Reads the policy and what it covers 1. Claim agent: Understands the incident and the claim situation 1. Document agent: Checks which documents are present, missing or inconsistent 1. Audit agent: Looks for gaps and contradictions across the file 1. Supervisor: Combines the four outputs into one clear next step ### Ritam Banks talk. Ritam checks. It reads a credit card statement, flags the charges that break RBI rules, and turns each finding into a complaint letter that cites the rule. - Recognition: Shinchan Online Hackathon 2026, Rank 7 - Built for: Credit card holders in India who think a bank has charged them wrongly - When: October to November 2026 - Tech stack: Python, FastAPI, Next.js, React, Tailwind CSS, PostgreSQL, Neo4j, Gemini, Groq, Vercel, Render - Rank 7 Shinchan Hackathon - 240+ automated tests - EN + HI English and Hindi - [Case study](https://siddhi-kale.vercel.app/work/ritam/) - [Live app](https://ritam-ten.vercel.app) - [GitHub](https://github.com/siddhi-works/Ritam) **Problem** A credit card bill mixes fees, interest and GST in a format few people read line by line, and the rules that limit those charges sit in RBI circulars. Most people either pay or give up, even when a charge looks wrong. **Solution** Ritam is a full-stack banking assistant for people in India. You describe a problem or upload a statement, and it checks the bill and the card’s terms against RBI rules. It can also work out the penalty when a card is not closed on time, and compare what changed on a card between two months. The AI is only allowed to read. It proposes facts from the document, code keeps only the facts the document confirms, and fixed rules decide what counts as a problem. Bills are not stored, and personal details are masked before any AI call. **How it was built** The backend is Python with FastAPI, async SQLAlchemy and a Postgres job queue. The frontend is Next.js with React and Tailwind CSS, with listen-aloud, larger text and high contrast options. A router sends language model calls across Gemini, Groq, Mistral and OpenRouter, so the free tiers are enough. It has 240+ automated tests with strict type checking, and CI runs on every push. The frontend is on Vercel and the API on Render. **Result** Ritam ranked 7th at the Shinchan Online Hackathon 2026, built within the 24-hour window and now live for anyone to try. The README is plain about its limits: it reports possible problems, not verdicts, it is not financial advice, and its bill test set is mostly synthetic. **How it works** 1. Describe: Type or speak the problem in English or Hindi. Ritam sends it to the right check; suspected fraud goes straight to blocking the card and calling 1930. 1. Read: Reads an uploaded statement PDF and lists the fees, interest and GST. 1. Check: Fixed rules compare each charge with RBI rules, such as late fees charged inside the 3-day grace period or interest on a no cost EMI. 1. Prove: Every finding points to the exact line it rests on, in the bill, the bank’s documents or the RBI text. 1. Act: Drafts a complaint letter that cites the RBI rule, says where to send it, and sets reminders for the bank’s reply deadline and the Ombudsman window. ### Plexis An add-on for Alexa+ that plans trips by voice. Your words become exact rules, a solver finds a plan that meets all of them, and an independent checker proves it before anything is booked. - Built for: Alexa+ customers who plan a trip by voice - When: November 2026 - Tech stack: Python, MCP, OR-Tools CP-SAT, Z3, LangGraph, Amazon Bedrock, Strands Agents, Pipecat, React, TypeScript, SQLite, Docker, GitHub Actions - 10 tools Alexa+ can call - 0 wrong plans on impossible requests - 89 ms median planning time - [Case study](https://siddhi-kale.vercel.app/work/plexis/) - [GitHub](https://github.com/siddhi-works/Plexis) **Problem** Many AI travel agents let a language model write the itinerary and then ask the user to check it. A plan that sounds right can still break a rule, like a connection that is too tight or a day over budget, and over a voice assistant nobody can see the plan to catch it. **Solution** Alexa+ connects to outside services through MCP. Plexis is an MCP server that plugs into Alexa+ as an add-on. It gives Alexa+ ten tools: plan a trip, change it, explain a choice, check better dates, book it, get a travel brief, call a hotel front desk, remember household preferences, show trip status, and verify a receipt. Alexa+ talks to the customer; Plexis does the deciding. The plan comes from a solver, not from a language model. When a request cannot be met, Plexis finds the smallest set of clashing rules, works out the smallest change that fixes them, and solves again to show the change works. A second tool, Z3, confirms independently that the conflict is real. **How it was built** The server speaks MCP over Streamable HTTP. A deterministic parser turns speech into 21 kinds of rule, a CP-SAT model chooses flights, stays, meals and activities and schedules each day, and Z3 confirms impossible requests. Every plan goes into a ledger: hashed, chained to the previous entry and signed with Ed25519, so any edit can be detected. Eight simulated partner services (transport, stays, dining, attractions, weather, a wallet, front-desk calls and destination research) sit behind it, and delays, errors and cancellations can be injected to test recovery. A voice client uses Pipecat, and a React simulator acts as an MCP client with a visible trace and proof view. It ships in Docker with 105 tests, and CI runs lint, security checks, tests and a benchmark. **Result** On my own benchmark of 80 seeded requests (70 solvable, 10 impossible), every plan passed every check and no impossible request got a wrong plan, against 13.8% and 25.0% plan pass rates for two greedy baselines. Median planning time was 89 ms. It is a functional prototype. Native Alexa+ deployment needs partner access, so it is demonstrated through an MCP-compatible Alexa+ simulator, and the travel and payment services are simulated, not live. **How it works** 1. Say it: You tell Alexa+ something like “Plan a weekend in Portland with Grandma under fifteen hundred dollars”. Alexa+ passes your words to Plexis, which asks for one missing detail at a time. 1. Compile: Plexis turns the words into exact, typed rules in about a millisecond. No language model decides anything at this step. 1. Solve: It collects flights, stays, restaurants, activities and weather from partner services, and a CP-SAT solver picks a plan that meets every rule. 1. Verify: A separate checker that shares no code with the solver recomputes every rule and price. Only a plan that passes everything is spoken. 1. Explain: Ask “Why not the Harbor Inn?” or “Make it cheaper”. If a request is impossible, Plexis names the rules that clash and the smallest fix, and proves the fix works. 1. Book: Say “Book it”. Plexis confirms the total, books through a hold-and-confirm flow that can undo itself, and signs a receipt you can check later. ### Verdict: Agentic SLA Auditor An audit system for outcome-based fleet contracts. It reads the contract, checks it against vehicle telemetry and automates a verdict only when every reasonable reading agrees; everything else goes to a person with a brief. - Recognition: Michelin x AI Tinkerers Harness Hackathon - Built for: Michelin x AI Tinkerers Harness Engineering Hackathon, Pune (Operations and Compliance track), extended afterwards - When: 2026 - Tech stack: Python, LLM reader, Deterministic decision engine, REST API, Tamper-evident audit log - 0 wrong automatic verdicts, against 28 for a single-reading baseline - 194 generated contracts evaluated - 108 tests in the suite - [Case study](https://siddhi-kale.vercel.app/work/verdict/) **Problem** Outcome-based fleet contracts pay on results such as uptime, so every period someone has to read the contract, pull the vehicle telemetry and decide whether the service level was met. Wording is vague, clauses conflict, precedence rules change the answer, and the telemetry itself is sometimes doubtful. An AI that simply answers is dangerous here. One invented threshold or a misread clause turns into a wrong payment. The hackathon, run by Michelin with AI Tinkerers in Pune, asked for a harness around the model that makes automation safe to trust. **Solution** Verdict is an agentic auditor that automates a verdict only when it is the same under every reasonable reading of the contract and the data. Otherwise it escalates to a person with a brief that includes the dollar range at stake. The model never decides. It acts as a reader that proposes numbers together with the exact sentence they came from; a quote verifier and a deterministic decision engine check the quote and make the call, so an invented threshold can never reach a verdict. A verdict envelope then tests conflicts, vague wording and precedence clauses against both trusted and doubtful telemetry views. **How it was built** It was built at the Michelin x AI Tinkerers Harness Engineering Hackathon in Pune (Operations and Compliance track) and extended afterwards. It ships with a tamper-evident audit trail with offline replay, a role-based review console, a secured REST API, run tracing and a test suite of 108 tests. Beyond generated contracts, the system ran on real public cloud SLAs from AWS and Google, added tiered service-credit support, and surfaced three reader defects that were fixed and locked in with regression tests. **Result** On 194 generated contracts, about 83,000 telemetry rows, Verdict produced 0 wrong automatic verdicts, against 28 for a single-reading baseline. An ablation that removed the verdict envelope caused 19 wrong automatic verdicts, which shows the envelope is what makes the automation safe. **How it works** 1. Read: An LLM reads the contract and proposes values, each with the exact source sentence 1. Verify: A quote verifier checks every proposed number against the contract text 1. Test: A verdict envelope tests each plausible reading of the contract against trusted and doubtful telemetry 1. Decide: Deterministic code decides, and only when the outcome is the same under every reading 1. Escalate: Anything unstable goes to a person with a brief and the dollar range at stake ### CensusGuru A citizen guide to Census 2027 in 5 languages: phases explained, state schedules, a self-enumeration practice run, a Gemini assistant and a misinformation claim checker. - Recognition: Built in 4 hours at PromptWars - Built for: PromptWars x ADYPU, a four-hour hackathon with Google for Developers and Hack2skill - When: 2026 - Tech stack: React, TypeScript, Vite, Express, Gemini, Zod, Vercel - 5 languages - 4 hours to build - 8 features - [Case study](https://siddhi-kale.vercel.app/work/censusguru/) - [Live app](https://censussetu.vercel.app) - [GitHub](https://github.com/siddhi-works/censussetu) - [LinkedIn post](https://www.linkedin.com/posts/siddhikale25_buildwithai-vibecoding-promptwars-ugcPost-7500774900912242688-c1bw/) **Problem** A census asks every household to take part, and many people are unsure what will be asked, who is allowed to ask it and which messages are genuine. That uncertainty is where rumours and scams spread. PromptWars gave four hours to build something useful with generative AI. I went for the part of Census 2027 that matters most to an ordinary citizen: understanding it and taking part safely. **Solution** CensusGuru is a citizen-first guide. It explains the census phases, lists state and UT schedules, lets people rehearse the digital self-enumeration process with demo data, and shows privacy and enumerator-safety guidance on how to recognise a suspicious request. Public Insights visualises reference statistics. AI Census Saathi answers questions using Google Gemini, and a claim checker helps test census-related claims. The whole interface works in English, Hindi, Marathi, Bengali and Kannada. **How it was built** Gemini is called from an Express server so the API key never reaches the browser. Inputs are validated with Zod, and selected common questions have deterministic fallback answers so the app still helps when the model does not. The simulator is clearly marked as demo-only: it never submits anything to a government system or generates a real Self-Enumeration ID. The repository includes a test file for the census logic. The front end is React, TypeScript and Vite, deployed on Vercel. **Result** A deployed, five-language product, shipped inside a four-hour hackathon. It also set a rule I still follow: with half an hour left, repeated AI-assisted edits broke a working build, so every change is now tested before the next one. **How it works** 1. Guide: The phases of Census 2027 in plain language 1. Schedules: A searchable reference of state and UT schedules 1. Practice: A self-enumeration simulator that uses demo data and submits nothing 1. Ask: AI Census Saathi answers questions through Gemini 1. Check: A claim checker for census-related misinformation ### Resolve IQ An AI ticket routing and resolution agent for enterprise IT support, built with Akriti Biswas for The Great Agent Hackathon. It classifies, prioritises and routes tickets, retrieves similar past issues and escalates uncertain cases to a person. - Built for: The Great Agent Hackathon - Team: With Akriti Biswas - When: 2026 - Tech stack: Python, scikit-learn, TF-IDF, Logistic Regression, Flask, SQLite - 8 pipeline stages - 4 priority levels - Human escalation built in - [Live app](https://resolveiq-bs1s.onrender.com) - [GitHub](https://github.com/siddhi-works/ai-ticket-routing-agent) - [LinkedIn post](https://www.linkedin.com/posts/siddhikale25_thegreatagenthackathon-ai-aiagents-ugcPost-7504510671020064768-3HgA/) **Problem** In enterprise IT support, tickets get misclassified, land with the wrong team and treat recurring problems as new ones. Simple requests wait behind complex ones, and engineers spend their time on triage instead of resolving. The hackathon asked for an agent that takes work off that queue, with one condition we held ourselves to: automation should support human responsibility and never hide it. **Solution** Resolve IQ runs every ticket through one pipeline: understand, classify, route, retrieve knowledge, assess confidence, resolve or escalate, and track. A TF-IDF and Logistic Regression classifier predicts the category, routing maps it to a team, and a priority estimate marks it urgent, high, medium or low. Similar past tickets and knowledge-base entries are retrieved to suggest a resolution, recurring issues are detected by comparing against earlier tickets, and a confidence score decides whether the system can act or must hand the ticket to a person. Low-confidence and sensitive cases always go to human review. **How it was built** The system has a ticket submission and queue interface, ticket history with search and filters, an analytics dashboard, CSV export and PDF reports, and pages that show each pipeline stage. Its modules are separated by stage: preprocessing, classification, confidence, routing, retrieval, resolution, escalation and recurring-issue detection. The classifier is trained on a generated, enterprise-style ticket dataset. The data is clean and generated, so its perfect validation accuracy on the current split says little about real tickets. The next step is testing against noisy, real-world ones. The roadmap includes semantic retrieval with embeddings, LLM-written resolution steps and integrations with tools like ServiceNow and Jira. **Result** An end-to-end triage agent with a full pipeline, a dashboard and a clear path to a human, built with Akriti Biswas for The Great Agent Hackathon. **How it works** 1. Understand: Clean the ticket text and extract what it is about 1. Classify: TF-IDF and Logistic Regression predict the category 1. Route: Map the category to the right support team and estimate priority 1. Retrieve: Find similar historical tickets and related knowledge 1. Decide: Score confidence, then resolve automatically or escalate to a person ### Skin Lesion Classifier A CNN in TensorFlow and Keras that classifies dermoscopic images as benign or malignant, with augmentation, early stopping and a Streamlit interface that returns a confidence score. 88 to 92% validation accuracy. - Tech stack: TensorFlow, Keras, Streamlit, scikit-learn - 88–92% validation accuracy - 3 conv layers - [GitHub](https://github.com/siddhi-works/Skin-Lesion-Classification-Using-Deep-Learning) - [LinkedIn post](https://www.linkedin.com/posts/siddhikale25_machinelearning-deeplearning-computervision-ugcPost-7448059968882421761-ccW-/) ### Chest X-Ray Detection ResNet-50 with transfer learning that sorts chest X-rays into COVID-19, viral pneumonia, lung opacity and normal, served through a Flask app for real-time prediction. 88 to 92% accuracy. - Tech stack: TensorFlow, Keras, ResNet-50, Flask, OpenCV - 88–92% accuracy - 4 classes - [GitHub](https://github.com/siddhi-works/ai-chest-xray-disease-detection) ### Plagiarism Detector NLP with TF-IDF and cosine similarity that finds duplicated content across a document set. 90% accuracy on 1,000 documents. - Tech stack: Python, NLTK, TF-IDF, Cosine similarity - 90% accuracy ### SkillPulse DevOps pipeline A three-tier app taken from commit to running update through GitHub Actions, with Kubernetes on a local kind cluster, worked through from the TrainWithShubham masterclass. - Tech stack: GitHub Actions, Docker, Kubernetes, CI/CD - [GitHub](https://github.com/siddhi-works/github-actions-demo) ## Services ### AI agents and LLM apps Multi-agent assistants and LLM applications that automate real workflows. Agents and checked-AI systems already at work on bank bills, insurance claims, trip plans, research papers and IT tickets, built with Gemini, LangGraph, LangChain and MCP. Deliverables: - A working agent scoped to one real task, end to end - Specialised agents with clear roles, orchestrated with LangGraph or LangChain - Retrieval over your documents and history - Support for the languages your users actually speak Process: Scope (Pick one task and define what a good answer looks like.) Build (Ship the thinnest version that does the job end to end.) Test (Run it on real examples and record what fails.) Ship (Deploy it and hand over the code.) ### Data dashboards and analytics Interactive dashboards and analytics that turn large datasets into clear insight. The dashboard that took First Prize at TechVerse 2026 turns 1.05 million records into 8 KPIs, 10 charts and a district map. Deliverables: - A dashboard with the KPIs that matter and the detail behind them - Maps and charts that answer a question - A data-trust page so readers know what the numbers can and cannot say - An assistant that answers questions from the data Process: Understand (Learn the data, its gaps and who will read the result.) Model (Clean it and agree on the few numbers that count.) Design (Build the views and test them with a real reader.) Publish (Ship it live with the sources visible.) ### Full-stack web apps Complete web applications, from database and API to a responsive interface. React and Next.js on the front end, FastAPI, Node.js, Express or Flask behind it, PostgreSQL or SQLite for data. Five of my projects are live, and every one has its code on GitHub. Deliverables: - A responsive app with accounts and the right access for each role - A backend and database that fit the problem - Multilingual interfaces where your audience needs them - Deployed, documented and handed over Process: Shape (Define the roles, the flows and the first release.) Build (Frontend and backend together, in small slices.) Harden (Login, errors, accessibility and speed.) Launch (Deploy and hand over.) ### Automation Pipelines that automate repetitive work and log every run. ARIA automates research from retrieval to a LaTeX paper. Resolve IQ classifies and routes IT tickets with TF-IDF and Logistic Regression. Deliverables: - A pipeline that takes a manual process from input to finished output - Classification and routing with a machine learning fallback - Logs and checks so every run can be inspected - Continuous delivery for the project itself Process: Map (Write down the manual steps and where the time goes.) Automate (Replace the tedious steps and keep judgement calls with a person.) Observe (Add logs and checks so nothing runs unseen.) Hand over (Document it so your team can own it.) ### Freelance work Project-based work with a clear scope, regular updates and code you own. Share what you need. You get a defined scope, visible progress and full ownership of the code. Deliverables: - A clear scope and timeline before any work starts - Visible progress instead of a reveal at the end - Code and documentation that you own - Direct contact with the person doing the work Process: Talk (Send a short note about what you need.) Scope (We agree the outcome, the timeline and the cost.) Build (You see progress as it happens.) Hand over (You get the code, the docs and a walkthrough.) ## Pages - Home: https://siddhi-kale.vercel.app/ - Resume page: https://siddhi-kale.vercel.app/resume/ - All projects: https://siddhi-kale.vercel.app/work/ - Full content as Markdown: https://siddhi-kale.vercel.app/llms-full.txt - Sitemap: https://siddhi-kale.vercel.app/sitemap.xml