Project: Customer Support Bot (Day 1)

pip install langchain langchain-community langchain-openai chromadb tiktoken

You will also need your OpenAI API key set in your environment variables.

Step 1: Create the "Knowledge Base"

First, we need data. Since we don't have a real company manual handy, let's write a script to generate some "fake" documentation for a fictional product called the GadgetPro 3000.

import os

# Create a directory for our documents
os.makedirs("support_docs", exist_ok=True)

# Document 1: Getting Started
doc1_content = """
# GadgetPro 3000: Getting Started Guide

Unboxing
Your GadgetPro 3000 comes with the main unit, a USB-C charging cable, and a protective case.
Please ensure all items are present before discarding the box.

Powering On
To turn on the device, press and hold the silver button on the right side for 3 seconds.
The LED indicator will flash blue when the device is ready.

Initial Setup
Download the GadgetPro app from the App Store. Enable Bluetooth on your phone.
Open the app and follow the on-screen pairing instructions.
"""

# Document 2: Troubleshooting
doc2_content = """
# GadgetPro 3000: Troubleshooting & FAQ

Device Won't Charge
Check if the USB-C cable is firmly connected.
Ensure you are using a 5V/2A power adapter.
If the LED blinks red, the battery is critically low. Leave it plugged in for 30 minutes.

Connection Issues
If the device disconnects frequently, try resetting the network settings.
Hold the volume up and power button simultaneously for 10 seconds.

Refund Policy
We offer a 30-day money-back guarantee. If you are not satisfied, contact support@gadgetpro.com.
Items must be returned in original packaging.
"""

# Write files to disk
with open("support_docs/getting_started.txt", "w") as f:
    f.write(doc1_content)

with open("support_docs/troubleshooting.txt", "w") as f:
    f.write(doc2_content)

print("Success: created 'support_docs' folder with 2 text files.")

Step 2: Loading the Documents

import os
from langchain_community.document_loaders import DirectoryLoader, TextLoader

def load_documents():
    print("Loading documents from ./support_docs...")
    
    # Initialize the loader to read all .txt files in the folder
    loader = DirectoryLoader(
        './support_docs', 
        glob="*/.txt", 
        loader_cls=TextLoader
    )
    
    # Load the data
    docs = loader.load()
    
    print(f"Successfully loaded {len(docs)} documents.")
    return docs

# Run the function to test
if __name__ == "__main__":
    raw_documents = load_documents()
    
    # Print a preview of the first document to verify
    print(f"\n--- Preview of first document ---")
    print(raw_documents[0].page_content[:200]) # First 200 chars

Step 3: Chunking (The Meat Grinder)

If we feed a 50-page manual into an AI all at once, two things happen:

from langchain_text_splitters import RecursiveCharacterTextSplitter

def split_documents(docs):
    print("\nSplitting documents into chunks...")
    
    # Create the splitter
    # chunk_size=500: Each chunk will be roughly 500 characters
    # chunk_overlap=50: The last 50 chars of chunk 1 will be the first 50 of chunk 2.
    # This overlap ensures we don't cut a sentence in half and lose context.
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=500,
        chunk_overlap=50,
        add_start_index=True
    )
    
    chunks = text_splitter.split_documents(docs)
    
    print(f"Split {len(docs)} documents into {len(chunks)} chunks.")
    return chunks

# Update the main block to test
if __name__ == "__main__":
    raw_documents = load_documents()
    chunks = split_documents(raw_documents)
    
    print(f"\n--- Preview of a chunk ---")
    print(chunks[1].page_content)
    print(f"Metadata: {chunks[1].metadata}")

Step 4: Storing in the Vector Database

Now we convert these text chunks into Embeddings (lists of numbers representing meaning) and store them in ChromaDB.

import shutil # Used to clear old database files
from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma

# Define where we want to save the database on disk
CHROMA_PATH = "chroma_db"

def save_to_chroma(chunks):
    # Clear out the database first to avoid duplicates if we run this script twice
    if os.path.exists(CHROMA_PATH):
        shutil.rmtree(CHROMA_PATH)
    
    # Initialize the OpenAI Embedding function
    # This is the "translator" that turns text into vectors
    embedding_function = OpenAIEmbeddings(api_key="YOUR_OPENAI_API_KEY") 

    print(f"\nSaving {len(chunks)} chunks to ChromaDB at {CHROMA_PATH}...")
    
    # Create the database from our documents
    db = Chroma.from_documents(
        chunks, 
        embedding_function, 
        persist_directory=CHROMA_PATH
    )
    
    print("Saved!")
    return db

if __name__ == "__main__":
    # 1. Load
    raw_documents = load_documents()
    
    # 2. Split
    chunks = split_documents(raw_documents)
    
    # 3. Store
    db = save_to_chroma(chunks)

Step 5: Verification (The "Does it work?" Test)

We aren't building the chat interface today, but we must verify the database works. We will perform a "Similarity Search." We will ask a question and see if the database returns the correct chunk of text.

from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings

CHROMA_PATH = "chroma_db"

def test_query():
    # Prepare the embedding function
    embedding_function = OpenAIEmbeddings(api_key="YOUR_OPENAI_API_KEY")

    # Load the existing database from disk
    db = Chroma(persist_directory=CHROMA_PATH, embedding_function=embedding_function)

    # The user's question
    query_text = "How do I get my money back?"
    print(f"Query: {query_text}")

    # Search the DB for the 3 most similar chunks
    results = db.similarity_search_with_score(query_text, k=3)

    print("\n--- Results ---")
    for doc, score in results:
        # Score: Lower is better (distance score)
        print(f"\nScore: {score:.4f}") 
        print(f"Source: {doc.metadata.get('source')}")
        print(f"Content: {doc.page_content}")

if __name__ == "__main__":
    test_query()

Even though the document uses the phrase "Refund Policy" and "money-back guarantee," and your query was "How do I get my money back?", the system should find the correct text. It understands the meaning of the request matches the meaning of the policy.

---

Now You Try

You have a working ingestion pipeline. Now, let's make it robust.

    db.similarity_search(query_text, k=3, filter={"source": "support_docs/troubleshooting.txt"})
    

---

Challenge Project: The Corporate Archive

Your manager has given you a folder containing simulated internal memos. Your job is to ingest them all and create a system that can identify which department a memo came from.

---

What You Learned

Today you moved away from writing logic and started building systems.