# Without LangChain - messy, repetitive code
        import openai

        response1 = openai.ChatCompletion.create(...)
        result1 = response1['choices'][0]['message']['content']

        response2 = openai.ChatCompletion.create(
            messages=[{"role": "user", "content": result1}]
        )
        result2 = response2['choices'][0]['message']['content']

        # Managing conversation history manually...
        # Handling errors manually...
        # Switching models manually...

# With LangChain - clean, composable
        from langchain import LLMChain, PromptTemplate
        from langchain.chat_models import ChatOpenAI

        chain = LLMChain(llm=ChatOpenAI(), prompt=my_prompt)
        result = chain.run(input_text)

        # Memory, error handling, model switching - all built in!

# Basic installation
        pip install langchain

        # With OpenAI
        pip install langchain openai

        # With other providers
        pip install langchain anthropic google-generativeai

        # All extras
        pip install langchain[all]

import os
        from langchain_openai import ChatOpenAI

        # Set API key
        os.environ["OPENAI_API_KEY"] = "your-key-here"

        # Or load from .env file
        from dotenv import load_dotenv
        load_dotenv()

        # Initialize model
        llm = ChatOpenAI(temperature=0.7, model="gpt-4o-mini")

from langchain_core.prompts import PromptTemplate
        from langchain_openai import ChatOpenAI

        # 1. Create prompt template
        prompt = PromptTemplate(
            input_variables=["product"],
            template="Generate 3 taglines for {product}"
        )

        # 2. Initialize LLM
        llm = ChatOpenAI(
            model="gpt-4o-mini",
            temperature=0.8
        )

        # 3. Create chain (LCEL style)
        chain = chain = prompt | llm

        # 4. Run chain
        result = chain.invoke(product="eco-friendly water bottle")
        print(result.content)

from langchain.chains import SimpleSequentialChain

        # Chain 1: Generate idea
        chain1 = LLMChain(llm=llm, prompt=idea_prompt)

        # Chain 2: Write opening
        chain2 = LLMChain(llm=llm, prompt=opening_prompt)

        # Combine them
        overall_chain = SimpleSequentialChain(
            chains=[chain1, chain2],
            verbose=True
        )

        result = overall_chain.run("mystery novel")

from langchain import PromptTemplate

        # 1. Basic template
        basic = PromptTemplate.from_template("Tell me about {topic}")

        # 2. Multi-variable template
        multi = PromptTemplate(
            template="""
        You are a {role}.
        Task: {task}
        Context: {context}
        Output format: {format}
        """,
            input_variables=["role", "task", "context", "format"]
        )

        # 3. Template with few-shot examples
        few_shot = PromptTemplate(
            template="""
        Examples:
        {examples}
        Now do: {input}
        """,
            input_variables=["examples", "input"]
        )

from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate

        # System message (sets behavior)
        system_template = "You are a helpful {role} who {style}."
        system_message = SystemMessagePromptTemplate.from_template(system_template)

        # Human message (user input)
        human_template = "{user_input}"
        human_message = HumanMessagePromptTemplate.from_template(human_template)

        # Combine into chat prompt
        chat_prompt = ChatPromptTemplate.from_messages([
            system_message,
            human_message
        ])

        # Format and use
        messages = chat_prompt.format_prompt(
            role="Python tutor",
            style="explains with examples",
            user_input="How do I use list comprehensions?"
        ).to_messages()

from langchain.memory import ConversationBufferMemory
        from langchain.chains import ConversationChain
        from langchain.chat_models import ChatOpenAI

        # 1. Create memory
        memory = ConversationBufferMemory()

        # 2. Create conversation chain with memory
        conversation = ConversationChain(
            llm=ChatOpenAI(temperature=0.7),
            memory=memory,
            verbose=True
        )

        # 3. Have a conversation
        response1 = conversation.predict(input="Hi, I'm learning LangChain")
        print(response1)

        response2 = conversation.predict(input="What was I just learning about?")
        print(response2)  # Remembers: "You're learning LangChain!"

        # 4. View conversation history
        print(memory.buffer)

from langchain.agents import load_tools, initialize_agent, AgentType
        from langchain.chat_models import ChatOpenAI

        # 1. Initialize LLM
        llm = ChatOpenAI(temperature=0)

        # 2. Load tools
        tools = load_tools([
            "serpapi",        # Web search
            "llm-math",       # Calculator
        ], llm=llm)

        # 3. Initialize agent
        agent = initialize_agent(
            tools=tools,
            llm=llm,
            agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
            verbose=True
        )

        # 4. Run agent
        result = agent.run("What's the square root of the population of Tokyo?")
        print(result)

from langchain.tools import BaseTool
        from typing import Optional

        # Method 1: Function decorator
        from langchain.tools import tool

        @tool
        def get_word_length(word: str) -> int:
            """Returns the length of a word"""
            return len(word)

        # Method 2: Custom Tool class
        class CustomSearchTool(BaseTool):
            name = "custom_search"
            description = "Useful for searching company database"

            def _run(self, query: str) -> str:
                # Your custom logic here
                results = search_company_db(query)
                return results

            def _arun(self, query: str):
                raise NotImplementedError("Async not supported")

        # Use custom tools with agent
        tools = [get_word_length, CustomSearchTool()]
        agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION)

from langchain.chat_models import ChatOpenAI
        from langchain.chains import ConversationChain
        from langchain.memory import ConversationBufferWindowMemory
        from langchain.prompts import (
            ChatPromptTemplate,
            SystemMessagePromptTemplate,
            HumanMessagePromptTemplate,
            MessagesPlaceholder
        )

        # 1. Create memory (keeps last 5 exchanges)
        memory = ConversationBufferWindowMemory(
            k=5,
            return_messages=True
        )

        # 2. Create prompt with memory placeholder
        prompt = ChatPromptTemplate.from_messages([
            SystemMessagePromptTemplate.from_template(
                "You are a helpful AI assistant for a tech company."
            ),
            MessagesPlaceholder(variable_name="history"),
            HumanMessagePromptTemplate.from_template("{input}")
        ])

        # 3. Create conversation chain
        conversation = ConversationChain(
            llm=ChatOpenAI(temperature=0.7),
            memory=memory,
            prompt=prompt,
            verbose=True
        )

        # 4. Chat loop
        while True:
            user_input = input("You: ")
            if user_input.lower() == "quit":
                break
            response = conversation.predict(input=user_input)
            print(f"AI: {response}")

from langchain.chat_models import ChatOpenAI
        from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler

        # Enable streaming
        llm = ChatOpenAI(
            temperature=0.7,
            streaming=True,
            callbacks=[StreamingStdOutCallbackHandler()]
        )

        # Use with chain
        chain = LLMChain(llm=llm, prompt=prompt)
        response = chain.run("Write a story about AI")

        # Text appears word by word!

from langchain.document_loaders import PyPDFLoader
        from langchain.text_splitter import RecursiveCharacterTextSplitter
        from langchain.embeddings import OpenAIEmbeddings
        from langchain.vectorstores import Chroma
        from langchain.chains import RetrievalQA
        from langchain.chat_models import ChatOpenAI

        # 1. Load document
        loader = PyPDFLoader("company_handbook.pdf")
        documents = loader.load()

        # 2. Split into chunks
        text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
        chunks = text_splitter.split_documents(documents)

        # 3. Create embeddings and store in vector DB
        embeddings = OpenAIEmbeddings()
        vectorstore = Chroma.from_documents(chunks, embeddings)

        # 4. Create retrieval QA chain
        qa_chain = RetrievalQA.from_chain_type(
            llm=ChatOpenAI(temperature=0),
            chain_type="stuff",
            retriever=vectorstore.as_retriever()
        )

        # 5. Ask questions!
        result = qa_chain.run("What's the vacation policy?")
        print(result)

from langchain.agents import initialize_agent, AgentType
        from langchain.chat_models import ChatOpenAI
        from langchain.tools import Tool
        from langchain.utilities import WikipediaAPIWrapper, PythonREPL

        # Define tools
        wikipedia = WikipediaAPIWrapper()
        python_repl = PythonREPL()

        tools = [
            Tool(
                name="Wikipedia",
                func=wikipedia.run,
                description="Search Wikipedia for factual information"
            ),
            Tool(
                name="Python_REPL",
                func=python_repl.run,
                description="Execute Python code for calculations"
            )
        ]

        # Create agent
        agent = initialize_agent(
            tools,
            ChatOpenAI(temperature=0),
            agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,
            verbose=True
        )

        # Complex research query
        result = agent.run("""
        What was the GDP of Japan in 2020, and what's 15% of that amount?
        """)

from langchain.chains import ConversationChain
        from langchain.memory import ConversationSummaryMemory
        from langchain.prompts import PromptTemplate

        # System prompt for support agent
        template = """You are a customer support agent for TechCorp.

        Current conversation:
        {history}

        Customer: {input}

        Guidelines:
        - Be helpful and empathetic
        - Check knowledge base before answering
        - Escalate complex issues to human agents
        - Always maintain professional tone

        Response:"""

        prompt = PromptTemplate(
            input_variables=["history", "input"],
            template=template
        )

        # Use summary memory for long conversations
        memory = ConversationSummaryMemory(
            llm=ChatOpenAI(temperature=0),
            max_token_limit=1000
        )

        # Create support chain
        support_chain = ConversationChain(
            llm=ChatOpenAI(temperature=0.7),
            prompt=prompt,
            memory=memory,
            verbose=True
        )

        # Handle customer queries
        response = support_chain.predict(input="My order hasn't arrived yet")

# Example: FastAPI + LangChain
        from fastapi import FastAPI
        from langchain.chains import ConversationChain

        app = FastAPI()

        # Initialize chain once
        chain = ConversationChain(llm=ChatOpenAI(), memory=memory)

        @app.post("/chat")
        async def chat(message: str):
            try:
                response = chain.predict(input=message)
                return {"response": response}
            except Exception as e:
                return {"error": str(e)}