Chatbot Basics

The simplest chatbot using LangChain + Ollama. Demonstrates conversation memory and prompt templates.

from langchain_ollama import OllamaLLM
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory

# Initialize the model (100% local, free)
llm = OllamaLLM(model="llama3.1", temperature=0.0)

# Create memory to maintain context
memory = ConversationBufferMemory()

# Build the conversation chain
conversation = ConversationChain(llm=llm, memory=memory)

# Chat!
response = conversation.predict(input="Hello, how are you?")
print(response)

Add tools to your chatbot so the LLM can perform actions like calculations and text summarization.

from langchain.tools import StructuredTool
from langchain.agents import initialize_agent, AgentType

# Define custom tools
def calculate_square(number: int) -> str:
    """Calculate the square of a number."""
    return str(number * number)

square_tool = StructuredTool.from_function(
    func=calculate_square,
    name="calculate_square",
    description="Calculates the square of a number"
)

# Create agent with tools
agent = initialize_agent(
    tools=[square_tool],
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION
)

# Agent decides when to use tools
result = agent.run("Calculate the square of 7")

Build a knowledge base using embeddings and FAISS for semantic search.

from sentence_transformers import SentenceTransformer
import faiss
import numpy as np

# Load embedding model
model = SentenceTransformer('all-MiniLM-L6-v2')

# Your knowledge base
texts = [
    "LangChain is a framework for LLM applications.",
    "FAISS enables fast similarity search.",
    "RAG reduces hallucinations by grounding responses."
]

# Generate embeddings
embeddings = model.encode(texts)
embeddings = embeddings / np.linalg.norm(embeddings, axis=1, keepdims=True)

# Create FAISS index
index = faiss.IndexFlatIP(embeddings.shape[1])
index.add(embeddings)

# Save for later use
faiss.write_index(index, "faiss_index/faiss.index")

def search_in_faiss(query: str, top_k: int = 2):
    """Search the knowledge base using semantic similarity."""
    # Encode query
    query_embedding = model.encode([query])
    query_embedding = query_embedding / np.linalg.norm(query_embedding)
    
    # Search in FAISS
    scores, indices = index.search(query_embedding, top_k)
    
    # Return results
    results = []
    for score, idx in zip(scores[0], indices[0]):
        if score > 0.35:  # Minimum threshold
            results.append({
                "text": texts[idx],
                "score": float(score)
            })
    return results

# Example search
results = search_in_faiss("What is RAG?")
print(results)

The final implementation combines conversation, tools, and RAG into one powerful agent.

# This agent has 3 tools:
# 1. calculate_square - Math operations
# 2. generate_text_summary - Text summarization  
# 3. search_in_faiss - Knowledge base retrieval

agent = initialize_agent(
    tools=[square_tool, summary_tool, rag_search_tool],
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    memory=memory
)

# The agent decides which tool to use
agent.run("Search in RAG for quality principles")
agent.run("Calculate the square of 15")
agent.run("Summarize this text: ...")