<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Tanish Bhongade</title>
    <description>The latest articles on DEV Community by Tanish Bhongade (@tanishbhongade).</description>
    <link>https://dev.to/tanishbhongade</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4165545%2F16eab979-a5b5-4d27-ad2e-5bac785abe88.jpg</url>
      <title>DEV Community: Tanish Bhongade</title>
      <link>https://dev.to/tanishbhongade</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/tanishbhongade"/>
    <language>en</language>
    <item>
      <title>Golden Lines</title>
      <dc:creator>Tanish Bhongade</dc:creator>
      <pubDate>Sat, 17 Oct 2026 15:19:50 +0000</pubDate>
      <link>https://dev.to/tanishbhongade/golden-lines-hme</link>
      <guid>https://dev.to/tanishbhongade/golden-lines-hme</guid>
      <description>&lt;p&gt;Golden Lines: A Personal Knowledge Graph That Remembers What Matters&lt;/p&gt;

&lt;p&gt;This is my submission for the "Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle" (&lt;a href="https://dev.to/challenges/hacktoberfest-week2-2026-10-12"&gt;https://dev.to/challenges/hacktoberfest-week2-2026-10-12&lt;/a&gt;).&lt;/p&gt;

&lt;p&gt;What I Built&lt;/p&gt;

&lt;p&gt;Golden Lines is a personal knowledge system for capturing, connecting, and retrieving the sentences worth remembering.&lt;/p&gt;

&lt;p&gt;We consume ideas from books, podcasts, conversations, articles, and people we admire. But most of those ideas end up scattered across notes, bookmarks, and documents. Even when we remember an idea, we often forget where it came from or how it connects to something else.&lt;/p&gt;

&lt;p&gt;I built Golden Lines to solve that problem.&lt;/p&gt;

&lt;p&gt;Instead of storing everything in an unstructured pile of notes, Golden Lines treats each meaningful sentence as an individual piece of knowledge. Every line can be connected to its speaker, topics, and source. I can then ask questions in natural language and let an AI agent retrieve relevant lines from my personal knowledge base.&lt;/p&gt;

&lt;p&gt;For example, I can ask, "What did I save about discipline?" or "Who said this, and what else do I know about them?" The system combines semantic search, structured relationships, and an AI agent to find relevant information.&lt;/p&gt;

&lt;p&gt;The most important design decision is that my knowledge belongs to me, not to the AI or the database.&lt;/p&gt;

&lt;p&gt;Golden Lines are stored as plain Markdown files. PostgreSQL, entity relationships, and vector embeddings are derived indexes that can be rebuilt from those files. The AI can search and reason over my knowledge, but it doesn't write or rewrite my canonical notes.&lt;/p&gt;

&lt;p&gt;Golden Lines is currently a personal knowledge system, but I see potential for researchers, writers, students, creators, and knowledge workers who want to build a searchable, reusable library of ideas.&lt;/p&gt;

&lt;p&gt;A future product could serve people who are willing to pay for a private, portable knowledge system that helps them retrieve and connect what they've learned over time.&lt;/p&gt;

&lt;p&gt;Demo&lt;/p&gt;

&lt;p&gt;The project currently runs through a CLI and an authenticated HTTP API.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Capture a golden line from the command line.&lt;/li&gt;
&lt;li&gt;Index Markdown files into PostgreSQL.&lt;/li&gt;
&lt;li&gt;Ask questions in natural language through an AI agent.&lt;/li&gt;
&lt;li&gt;Browse saved lines and entities through the API.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;I haven't published a hosted demo yet, so the repository is the best place to explore the implementation and setup instructions.&lt;/p&gt;

&lt;p&gt;Code&lt;/p&gt;

&lt;p&gt;GitHub repository: &lt;a href="https://github.com/tanishbhongade/golden-lines" rel="noopener noreferrer"&gt;https://github.com/tanishbhongade/golden-lines&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The project is built in Python and organized into distinct layers:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;"app/capture/" — captures new golden lines.&lt;/li&gt;
&lt;li&gt;"app/indexer/" — parses Markdown, resolves entities, generates embeddings, and updates the database.&lt;/li&gt;
&lt;li&gt;"app/retrieval/" — handles semantic search, entity resolution, and relationship queries.&lt;/li&gt;
&lt;li&gt;"app/tools/" — exposes retrieval functions to the AI agent.&lt;/li&gt;
&lt;li&gt;"app/graph/" — orchestrates the agent using LangGraph.&lt;/li&gt;
&lt;li&gt;"app/api/" — provides authenticated HTTP endpoints using FastAPI.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The database uses PostgreSQL with pgvector for semantic search and "pg_trgm" for similarity-based entity resolution.&lt;/p&gt;

&lt;p&gt;How I Built It&lt;/p&gt;

&lt;p&gt;I wanted to build something where AI adds intelligence without becoming the owner of the underlying data.&lt;/p&gt;

&lt;p&gt;The system uses a combination of traditional software engineering and AI-powered retrieval.&lt;/p&gt;

&lt;p&gt;The knowledge layer&lt;/p&gt;

&lt;p&gt;Every golden line is a Markdown file with YAML frontmatter containing metadata such as its title, speaker, topics, and source. These files are the canonical records, making the knowledge base human-readable, portable, and version-control friendly.&lt;/p&gt;

&lt;p&gt;The indexing layer&lt;/p&gt;

&lt;p&gt;A deterministic Python pipeline parses the files, extracts entity references, resolves them against existing entities, and generates embeddings. PostgreSQL stores the resulting structured relationships and vector representations.&lt;/p&gt;

&lt;p&gt;The retrieval layer&lt;/p&gt;

&lt;p&gt;The application combines vector similarity with relational queries. This allows it to search by meaning while also answering questions about specific people, topics, and their associated lines.&lt;/p&gt;

&lt;p&gt;The AI agent&lt;/p&gt;

&lt;p&gt;I used LangGraph to orchestrate an agent that can call retrieval tools, inspect the results, and answer questions grounded in the available knowledge. The model decides which tools to use; the tools perform the actual data retrieval.&lt;/p&gt;

&lt;p&gt;For the model layer, I used AWS Bedrock with configurable model identifiers. The documented defaults are Amazon Titan Text Embeddings V2 for embeddings and DeepSeek V3 for language-model reasoning.&lt;/p&gt;

&lt;p&gt;I deliberately kept the agent's access to canonical knowledge read-only. Capturing new knowledge is an explicit user action, while the database and embeddings remain rebuildable projections.&lt;/p&gt;

&lt;p&gt;This separation means I can change the database or model implementation without losing the underlying knowledge.&lt;/p&gt;

&lt;p&gt;Why Does Open Innovation Matter?&lt;/p&gt;

&lt;p&gt;Open innovation matters because a personal knowledge system should not require a permanent commitment to one AI provider, database, or proprietary note-taking platform.&lt;/p&gt;

&lt;p&gt;Golden Lines is built on open-source frameworks and portable data formats. Python, FastAPI, LangGraph, PostgreSQL, pgvector, and Markdown each play a distinct role in the system.&lt;/p&gt;

&lt;p&gt;That combination made it possible to experiment with AI-powered retrieval while retaining control over the data model and application architecture.&lt;/p&gt;

&lt;p&gt;It also makes the project easier to inspect, adapt, and extend. Someone could replace the embedding model, change the language model, build a different interface, or reuse the indexing pipeline without having to rebuild the entire system from scratch.&lt;/p&gt;

&lt;p&gt;I use configurable model identifiers so that changing models doesn't require rewriting the application around a particular provider's API.&lt;/p&gt;

&lt;p&gt;There is an important distinction here: the application and its core architecture are built with open-source technologies, while the currently configured models are accessed through AWS Bedrock. The system is designed to make model substitution easier, although switching to local or open-weight inference would still require configuring a compatible inference backend.&lt;/p&gt;

&lt;p&gt;For me, open innovation is about retaining the freedom to experiment, learn from existing work, and build something that remains useful even as the AI ecosystem changes.&lt;/p&gt;

</description>
      <category>devchallenge</category>
      <category>hf26challenge</category>
    </item>
    <item>
      <title>TimeWalk: A Walking Companion That Tells You What Happened Where You're Standing</title>
      <dc:creator>Tanish Bhongade</dc:creator>
      <pubDate>Tue, 06 Oct 2026 18:42:35 +0000</pubDate>
      <link>https://dev.to/tanishbhongade/timewalk-a-walking-companion-that-tells-you-what-happened-where-youre-standing-33m9</link>
      <guid>https://dev.to/tanishbhongade/timewalk-a-walking-companion-that-tells-you-what-happened-where-youre-standing-33m9</guid>
      <description>&lt;p&gt;&lt;em&gt;This is my submission for the &lt;a href="https://dev.to/challenges/hacktoberfest-week1-2026-10-05"&gt;Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What I Built
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;TimeWalk&lt;/strong&gt; is a location-aware historical storytelling backend. You give it a GPS coordinate and a question like &lt;em&gt;"What is the history of this place?"&lt;/em&gt; — it gives you back a short, source-grounded story about where you're standing.&lt;/p&gt;

&lt;p&gt;It's built for travelers, walkers, and anyone who has ever stood in front of a building and wondered what happened there before. Open the app, get your location, get the story.&lt;/p&gt;

&lt;p&gt;The tagline I kept coming back to while building it:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Where am I, what happened here, and can the AI prove it?&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;The "Touch Grass" framing fits exactly. The point isn't to keep you on your phone — it's to give you &lt;em&gt;just enough&lt;/em&gt; context in &lt;em&gt;just enough&lt;/em&gt; time that you look up, look around, and actually see the place you're in. Sections are short. Language is plain. Sources are there when you want them, tucked at the bottom. Nearby places are things you can walk to.&lt;/p&gt;

&lt;p&gt;It's a backend-only submission for now. The mobile frontend is the next milestone.&lt;/p&gt;

&lt;h2&gt;
  
  
  Demo
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;&lt;a href="https://youtu.be/56wxT7VzJVw" rel="noopener noreferrer"&gt;Watch the demo →&lt;/a&gt;&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;In the video, I run a live request for &lt;strong&gt;Kasba Peth, Pune&lt;/strong&gt; (18.5204°N, 73.8567°E). Watch for:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The &lt;strong&gt;place resolution&lt;/strong&gt; — the backend identifies the exact locality, not just the city&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;10–30 second research phase&lt;/strong&gt; — this is where the model is actually searching, reading, and synthesizing&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;final structured story&lt;/strong&gt; — with short readable sections, a &lt;code&gt;whyHere&lt;/code&gt; line for each, and sources at the bottom&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;nearby places&lt;/strong&gt; — historical sites within walking distance, each with a distance&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;uncertainty field&lt;/strong&gt; — because honest history admits what it doesn't know&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Every section in the output is grounded in a source the model actually retrieved. Nothing is fabricated.&lt;/p&gt;

&lt;h2&gt;
  
  
  Code
&lt;/h2&gt;

&lt;p&gt;Repo: &lt;code&gt;github.com/tanish/timewalk&lt;/code&gt; &lt;em&gt;(&lt;a href="https://github.com/tanishbhongade/timewalk" rel="noopener noreferrer"&gt;https://github.com/tanishbhongade/timewalk&lt;/a&gt;)&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Structure:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;src/
├── agent/              # Two-phase LLM agent (research + synthesis)
├── controllers/        # HTTP edge
├── middleware/         # Auth, rate limiting, validation, errors
├── providers/
│   ├── geocoder/       # Nominatim adapter
│   ├── search/         # Tavily adapter, Wikipedia-first
│   └── llm/            # Bedrock factory
├── routes/
├── schemas/            # Zod schemas for everything
└── services/           # Domain logic
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Stack: &lt;strong&gt;Node.js + TypeScript + Express&lt;/strong&gt;, &lt;strong&gt;AWS Bedrock&lt;/strong&gt; for the LLM, &lt;strong&gt;Tavily&lt;/strong&gt; for web research, &lt;strong&gt;Nominatim&lt;/strong&gt; for reverse geocoding, &lt;strong&gt;Zod&lt;/strong&gt; for validation, &lt;strong&gt;JWT&lt;/strong&gt; for auth.&lt;/p&gt;

&lt;h2&gt;
  
  
  How I Built It
&lt;/h2&gt;

&lt;h3&gt;
  
  
  The model
&lt;/h3&gt;

&lt;p&gt;I'm using &lt;strong&gt;&lt;code&gt;google.gemma-3-27b-it&lt;/code&gt;&lt;/strong&gt; on AWS Bedrock. Open weights, 27B parameters.&lt;/p&gt;

&lt;p&gt;The honest comparison from my testing:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Ministral 3 8B&lt;/strong&gt; was too small. It latched onto the wrong noun in the prompt (a library name instead of the neighborhood) and hallucinated a plausible-sounding history of the wrong place. The output &lt;em&gt;looked&lt;/em&gt; fine — correct schema, plausible prose — but it was describing Delhi for Pune's coordinates.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Gemma 3 27B&lt;/strong&gt; nailed it: correct scope, real sources, honest confidence labels, thoughtful caveats.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  The two-phase agent
&lt;/h3&gt;

&lt;p&gt;The key architectural decision, and it took me a while to get right:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Phase 1 — Research.&lt;/strong&gt; The LLM gets three tools and a bounded budget (&lt;code&gt;AGENT_MAX_TOOL_CALLS=6&lt;/code&gt;). It decides what to search for and calls the tools. No output format constraints. Its only job is to gather evidence.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Phase 2 — Synthesis.&lt;/strong&gt; A second LLM call with no tools. Its only job is to turn the gathered evidence into a strict JSON response.&lt;/p&gt;

&lt;h3&gt;
  
  
  Source grounding
&lt;/h3&gt;

&lt;p&gt;This is where the "can the AI prove it?" promise gets kept. Three enforcement mechanisms:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;The prompt&lt;/strong&gt; tells the model never to invent URLs, dates, people, or buildings.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The synthesis step&lt;/strong&gt; requires every factual claim to reference a source ID from the evidence the research agent collected.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A scrubber&lt;/strong&gt; runs after synthesis — it collects the set of source IDs that tools &lt;em&gt;actually&lt;/em&gt; returned and filters the model's output against that set.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;This is a hard boundary. It makes fabrication structurally impossible, not just discouraged.&lt;/p&gt;

&lt;h3&gt;
  
  
  Wikipedia-first search
&lt;/h3&gt;

&lt;p&gt;Tavily's &lt;code&gt;includeDomains&lt;/code&gt; parameter lets me restrict the first search to Wikipedia. If Wikipedia has a page for the place, that's the only result the model sees — one clean tier-1 source. If it doesn't, the search falls through to a broader query.&lt;/p&gt;

&lt;p&gt;The result: clean sources for well-covered places, and graceful degradation for the long tail.&lt;/p&gt;

&lt;h3&gt;
  
  
  What I got wrong along the way
&lt;/h3&gt;

&lt;p&gt;Three bugs worth mentioning, because each one taught me something:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Bedrock rejected my synthesis prompt&lt;/strong&gt; with &lt;code&gt;The toolConfig field must be defined when using toolUse and toolResult content blocks&lt;/code&gt;. I'd been replaying the raw tool-call conversation into the synthesis call, and Bedrock's API is stricter than OpenAI's about orphaned tool blocks. Fixed by extracting evidence into a plain text block instead of replaying messages.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;The model returned &lt;code&gt;sources&lt;/code&gt; objects without &lt;code&gt;id&lt;/code&gt; fields&lt;/strong&gt;, breaking schema validation. Fixed by making &lt;code&gt;id&lt;/code&gt; optional in the schema and deriving it deterministically from the URL when missing.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Confidence labels drifted to "high" for everything&lt;/strong&gt;, including claims the model's own caveats said were tradition-based. Fixed by adding a prompt rule: if the narration hedges, the confidence must not be "high."&lt;/p&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Why Does Open Innovation Matter?
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;The real reason open weights mattered for this project:&lt;/strong&gt; I could actually compare models on the same pipeline and pick the one that worked. I didn't have to commit to a vendor before I knew whether the model was good enough. I ran DeepSeek, Ministral, and Gemma through identical prompts, identical tools, identical responses — and Gemma 3 27B won on the thing that actually mattered (grounding).&lt;/p&gt;

&lt;p&gt;With a closed API, that comparison would have cost me three integrations and several days of glue code. With open weights served through an OpenAI-compatible interface, it was a one-line env var change.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Three other reasons this build leans on open:&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Cost predictability.&lt;/strong&gt; A hobby project can't run up a $500 OpenAI bill in a weekend of testing. Open weights on a pay-per-token host let me iterate without worrying about the meter.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Data privacy.&lt;/strong&gt; A location-aware app is a privacy-sensitive product. Users are telling me where they are, in real time. With open weights, I have the option to self-host later — the queries never have to leave infrastructure I control. That's an option I'd lose with a closed model, and it's one I want to keep open as the app grows.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Iteration speed.&lt;/strong&gt; I changed the prompt maybe 40 times during development. Every one of those iterations had to fire a model call. Being able to swap models, adjust temperature, and try different providers without re-architecting anything is what made the whole two-phase design discoverable at all.&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The "can the AI prove it?" framing only works if you can &lt;em&gt;test&lt;/em&gt; the AI. Open weights gave me that.&lt;/p&gt;

&lt;h2&gt;
  
  
  Prize Categories
&lt;/h2&gt;

&lt;p&gt;Best Use of Gemma&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;One last thing.&lt;/strong&gt; The reason this project exists isn't that I wanted to build a history app. It's that I wanted to build something that makes a person standing on a street corner look up and see a place differently. Every architectural decision — the short sections, the &lt;code&gt;whyHere&lt;/code&gt; line, the sources tucked at the bottom — exists to serve that moment.&lt;/p&gt;

&lt;p&gt;If you build something like this, I'd love to hear what you learn. Especially if you try it in a place without a Wikipedia page. That's the real test.&lt;/p&gt;




</description>
      <category>devchallenge</category>
      <category>hf26challenge</category>
    </item>
  </channel>
</rss>
