{
  "nbformat": 4,
  "nbformat_minor": 5,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.x"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# LangChain Course: From Basics to Intermediate\n",
        "Welcome to this hands-on LangChain course. Over 20 cells, we'll cover core concepts, build chains, use memory, agents, retrieval, and more."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Course Overview & Prerequisites\n",
        "**Objectives:** Learn how to create LLM-driven applications using LangChain.\n",
        "**You'll learn to:**\n",
        "- Install and configure LangChain and dependencies.\n",
        "- Build simple LLMChains and run them.\n",
        "- Manage conversation memory.\n",
        "- Design advanced prompt templates.\n",
        "- Integrate agents with external tools.\n",
        "- Load documents and build RAG workflows.\n",
        "- Monitor performance with callbacks.\n",
        "\n",
        "Prerequisites:\n",
        "- Python 3.8+ installed.\n",
        "- An OpenAI API key set as `OPENAI_API_KEY`.\n",
        "- Basic Python knowledge."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# 1. Install Dependencies\n",
        "!pip install langchain openai faiss-cpu wikipedia tqdm"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 2. Initialization\n",
        "Import core classes and initialize your LLM with sensible defaults."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "from langchain import LLMChain, PromptTemplate\n",
        "from langchain.llms import OpenAI\n",
        "\n",
        "# Initialize OpenAI LLM\n",
        "llm = OpenAI(temperature=0.5, max_tokens=150)\n",
        "print('LLM initialized:', llm)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 3. Build Your First LLMChain\n",
        "An `LLMChain` ties a prompt template to an LLM. We'll create a personalized greeting chain."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Define a simple prompt template\n",
        "template = 'Hello, {name}! Welcome to LangChain on {date}.'\n",
        "prompt = PromptTemplate(input_variables=['name','date'], template=template)\n",
        "chain = LLMChain(llm=llm, prompt=prompt)\n",
        "\n",
        "# Run the chain\n",
        "from datetime import datetime\n",
        "output = chain.run({'name':'Alice','date': datetime.now().strftime('%Y-%m-%d')})\n",
        "print(output)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 4. Conversation Memory\n",
        "Use `ConversationBufferMemory` to keep track of past messages and context."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "from langchain.memory import ConversationBufferMemory\n",
        "\n",
        "# Set up memory and chain\n",
        "memory = ConversationBufferMemory()\n",
        "chain_mem = LLMChain(llm=llm, prompt=prompt, memory=memory)\n",
        "\n",
        "# Run with context retained\n",
        "print(chain_mem.run({'name':'Bob','date':'2025-05-18'}))\n",
        "print(chain_mem.run({'name':'Carol','date':'2025-05-19'}))\n",
        "\n",
        "# Inspect memory buffer\n",
        "print('Memory buffer:', memory.buffer)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 5. Advanced Prompt Templates\n",
        "Delegate complex formatting to LangChain’s `PromptTemplate`. Example: translation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Translation example\n",
        "translate_template = 'Translate the following text to {language}: {text}'\n",
        "translate_prompt = PromptTemplate(input_variables=['language','text'], template=translate_template)\n",
        "formatted = translate_prompt.format(language='French', text='LangChain simplifies LLM apps.')\n",
        "print(formatted)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 6. Agents & Tools\n",
        "Agents enable your chain to call external tools. Here’s a zero-shot agent with Wikipedia lookup."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "from langchain.agents import initialize_agent, Tool\n",
        "from langchain.tools import WikipediaQueryRun\n",
        "\n",
        "wiki_tool = Tool(\n",
        "    name='wiki',\n",
        "    func=WikipediaQueryRun().run,\n",
        "    description='Search Wikipedia for factual queries'\n",
        ")\n",
        "agent = initialize_agent([wiki_tool], llm, agent='zero-shot-react-description', verbose=True)\n",
        "# Ask agent a question\n",
        "print(agent.run('Who was Ada Lovelace?'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 7. Document Loading & Vector Stores\n",
        "Load files (PDF, text) and build FAISS indexes for semantic retrieval."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "from langchain.document_loaders import PyPDFLoader\n",
        "from langchain.embeddings import OpenAIEmbeddings\n",
        "from langchain.vectorstores import FAISS\n",
        "\n",
        "# Load a PDF document\n",
        "loader = PyPDFLoader('example.pdf')\n",
        "docs = loader.load()\n",
        "\n",
        "# Create embeddings and index\n",
        "embeddings = OpenAIEmbeddings()\n",
        "vectorstore = FAISS.from_documents(docs, embeddings)\n",
        "\n",
        "print(f'Indexed {len(docs)} documents into FAISS.')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 8. RetrievalQA Chain\n",
        "Combine retrieval with generation to answer questions over your documents."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "from langchain.chains import RetrievalQA\n",
        "\n",
        "qa_chain = RetrievalQA.from_chain_type(\n",
        "    llm=llm,\n",
        "    chain_type='stuff',\n",
        "    retriever=vectorstore.as_retriever()\n",
        ")\n",
        "# Example question\n",
        "response = qa_chain.run('What is the main topic of the document?')\n",
        "print('Answer:', response)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 9. Callback Handlers\n",
        "Monitor token usage, cost, and latency with `get_openai_callback`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "from langchain.callbacks import get_openai_callback\n",
        "\n",
        "with get_openai_callback() as cb:\n",
        "    result = chain.run({'name':'Dave','date':'2025-05-20'})\n",
        "print('Output:', result)\n",
        "print(f'Total tokens: {cb.total_tokens}, Prompt tokens: {cb.prompt_tokens}, Completion tokens: {cb.completion_tokens}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 10. Next Steps & Exploration\n",
        "Having covered chains, memory, templates, agents, retrieval, and callbacks, explore:\n",
        "- Custom chain classes and asynchronous execution.\n",
        "- Integration with Streamlit, FastAPI, or Flask for web UIs.\n",
        "- Multi-agent orchestration and tool chaining.\n",
        "- Optimizing prompt engineering for production cost and latency.\n",
        "\n",
        "Happy building!"
      ]
    }
  ]
}