Chatbot on Pythonflow

LangBot Day 10: Agents and Tool Calling — Let the LLM Decide What to Do

alicandonmez90@gmail.com (flowfelis) — Sat, 27 Jun 2026 07:00:00 +0100

Recap: On Day 9, LangBot became a full RAG pipeline — every chat message retrieves relevant documents and the LLM answers from them. The /search command, list-mode routing, and regular chat all coexist. But there is a problem hiding in plain sight: the routing logic is hand-coded in if/elif blocks. LangBot doesn’t decide anything — it follows a script. Today we replace that script with an agent: an LLM that reasons about which tool to use, calls it, and responds — autonomously.

LangBot Day 9: The RAG Pipeline — Retriever Meets Generator

alicandonmez90@gmail.com (flowfelis) — Fri, 26 Jun 2026 07:00:00 +0100

Recap: On Day 8, LangBot gained a long-term memory — a vector store (Pinecone) filled with document embeddings. You can ask /search home office stipend and get relevant chunks back. But that is half the picture. You still have to type /search, read raw chunks, and synthesize the answer yourself. Today we close the loop: the retriever feeds into the chatbot automatically, so you ask “How much is the home office stipend?” and LangBot answers from your documents — no slash command, no manual lookup.

LangBot Day 8: Retrieval — Vector Stores, Embeddings, and Pinecone

alicandonmez90@gmail.com (flowfelis) — Thu, 25 Jun 2026 07:00:00 +0100

Recap: On Day 7, LangBot learned to stream — token-by-token responses that feel like a real chat app. It remembers the conversation within a session (Day 2 memory), it has a personality (Day 3 prompt templates), it returns typed data (Day 5 structured output), it handles lists (Day 6 output parsers), and it streams those replies in real time (Day 7). But ask it anything outside its training data and it either guesses, hallucinates, or apologizes. Today we fix that by giving LangBot the ability to search external documents — the retrieval half of RAG.

LangBot Day 7: Streaming Output — Token-by-Token Responses

alicandonmez90@gmail.com (flowfelis) — Tue, 23 Jun 2026 07:00:00 +0100

Recap: On Day 6, LangBot gained output parsers and now responds in two modes — chat mode returns typed LangBotResponse objects with mood and confidence, and list mode returns clean list[str] via CommaSeparatedListOutputParser. Both modes use .invoke(), which means the entire response arrives at once after the model finishes generating. Today we fix that — LangBot learns to type its replies one token at a time.

The problem: waiting for the whole answer

Every interaction so far has the same rhythm:

LangBot Day 6: Output Parsers — Transforming Raw Responses into Usable Data

alicandonmez90@gmail.com (flowfelis) — Mon, 22 Jun 2026 07:00:00 +0100

Recap: On Day 5, LangBot started returning typed objects — every response is now a LangBotResponse with .message, .mood, and .confidence. That is great when you need structured metadata. But structured output is not always the right tool. Sometimes you just want a clean string. Sometimes you want a parsed list. Today we add output parsers — lightweight LCEL components that transform raw AIMessage output into exactly the shape you need.

LangBot Day 5: Structured Output — Typed Responses with Pydantic

alicandonmez90@gmail.com (flowfelis) — Sun, 21 Jun 2026 07:00:00 +0100

Recap: Yesterday we wired LangBot’s prompt and model into one pipeline with LCEL’s pipe operator — chain = prompt | llm. One invoke() call now handles everything from formatting to generation. But we still get back a raw AIMessage and have to reach into .content for the text. Today LangBot returns real typed objects.

The problem: unstructured mush

Every LLM response so far has been an AIMessage — a blob of text with no shape. To extract anything useful, you either parse it yourself or pray the model followed your formatting instructions. Both are fragile.

LangBot Day 4: Chaining with LCEL — The Pipe Operator

alicandonmez90@gmail.com (flowfelis) — Sat, 20 Jun 2026 07:00:00 +0100

Recap: On Day 1 we built a basic CLI chatbot. Day 2 gave it memory so it remembers the conversation. Day 3 added a prompt template so LangBot has a personality. But every turn still requires two separate steps — format the template, then call the model. Today we stitch them together into one fluid pipeline.

The problem: two steps where one should do

Here is how LangBot works on Day 3. Every single turn:

LangBot Day 3: Giving Your Chatbot a Personality with Prompt Templates

alicandonmez90@gmail.com (flowfelis) — Fri, 19 Jun 2026 07:00:00 +0100

Recap: On Day 1 we built a CLI chatbot with ChatOpenAI. On Day 2 we gave it memory so it remembers the conversation. But LangBot still has no personality — every session starts with a blank slate, and the model defaults to its generic “helpful assistant” tone. Today we change that.

The problem: a chatbot with no identity

Right now, LangBot’s response to any first message is unpredictable. Ask “What do you do?” and you get whatever the base model decides. There is no way to control:

LangBot Day 2: Giving Your Chatbot a Memory with Conversation History

alicandonmez90@gmail.com (flowfelis) — Thu, 18 Jun 2026 07:00:00 +0100

Recap: Yesterday we built LangBot — a 27-line CLI chatbot powered by ChatOpenAI. It works, but every message starts from scratch. Ask “What’s my name?” and it invents one. Remind it “My name is Alex” and ask again — it still guesses. Today we fix that.

The problem: amnesia mode

Try this in Day 1’s LangBot:

You: My favorite color is blue.

LangBot: That's a great choice! Blue is calming and versatile.

You: What did I just say my favorite color was?

LangBot: I'm not sure — you haven't mentioned a favorite color in this conversation.

Every call to llm.invoke() sends a single HumanMessage. The model has zero context from previous turns. For a real chatbot, this is a dealbreaker.

LangBot Day 1: Building a Chatbot with LangChain from Scratch

alicandonmez90@gmail.com (flowfelis) — Wed, 17 Jun 2026 07:00:00 +0100

Welcome to LangBot — a daily tutorial series where we build one chatbot app from scratch using LangChain . Every post adds one new concept to the same codebase, so by the end you will have a production-ready chatbot and a solid mental model of how LangChain works.

No magic. No abandoned side projects. One app, built in public, one concept at a time.

What we are building

LangBot is a conversational chatbot that runs in your terminal. Today it will be simple: you type a message, it replies. But every day this week we will add memory, prompt templates, structured output, retrieval, agents, streaming, and more — all in the same codebase.