LangChain is a comprehensive framework designed to streamline the development of advanced language model-powered applications. It provides modular components, standardized interfaces, and integration tools that enable developers to build end-to-end systems leveraging large language models (LLMs) and chat models efficiently.

At its core, LangChain operates through several foundational concepts:

• Components and Chains: Modular building blocks called Components can be combined into Chains—sequential workflows that execute specific tasks. For example, a Chain might integrate a prompt template, an LLM, and an output parser to process user input, generate responses, and structure results.

• Prompt Templates and Values: These templates dynamically format inputs using variables and context. They produce PromptValue objects, which are converted into appropriate formats—such as text or chat message sequences—for consumption by different models.

• Example Selectors: These dynamically inject relevant examples into prompts based on user input, enhancing contextual accuracy and performance in retrieval-augmented generation scenarios.

• Output Parsers: Responsible for transforming raw model outputs into structured data types like JSON or custom objects. They define formatting instructions and parsing logic, enabling consistent downstream processing.

• Indexes and Retrievers: Indexes organize document collections for efficient access. Retrievers fetch semantically relevant documents from these indexes, allowing LLMs to ground their responses in external knowledge sources such as databases or vector stores.

• Chat Message History: Maintains conversation state across interactions via the ChatMessageHistory class. This enables context retention and improves coherence in multi-turn dialogues.

• Agents and Toolkits: Agents act as decision-making entities capable of selecting and invoking tools based on input. Tooolkits bundle related functions, while AgentExecutors manage execution flow, enabling complex, adaptive workflows.

To get started, install the library:

pip install langchain

For integration with OpenAI services, also install:

pip install openai

Set your API key either via environment variable:

export OPENAI_API_KEY=your_key_here
``

Or programmatically:

import os os.environ["OPENAI_API_KEY"] = "your_key_here" ``

Use a chat model with message-based interaction:

from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, AIMessage, SystemMessage

chat = ChatOpenAI(temperature=0)

# Single message
response = chat([HumanMessage(content="Translate 'I love coding' to French")])
print(response.content)  # Output: J'aime coder.

# Multi-turn conversation
messages = [
    SystemMessage(content="You translate English to Chinese."),
    HumanMessage(content="Translate 'I love coding' to Chinese")
]
response = chat(messages)
print(response.content)  # Output: 我喜欢编程。
``

Generate batch responses using `generate`:

batch_messages = [ [SystemMessage(content="Translate English to Chinese."), HumanMessage(content="I love coding")], [SystemMessage(content="Translate English to Chinese."), HumanMessage(content="I love AI")] ] result = chat.generate(batch_messages) print(result.llm_output['token_usage']) ``

Leverage templates with ChatPromptTemplate:

from langchain.prompts.chat import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate

template = "You are a translator from {source} to {target}."
system_prompt = SystemMessagePromptTemplate.from_template(template)
human_prompt = HumanMessagePromptTemplate.from_template("{text}")
chat_prompt = ChatPromptTemplate.from_messages([system_prompt, human_prompt])
formatted = chat_prompt.format_prompt(source="English", target="Chinese", text="I love coding")
response = chat(formatted.to_messages())
``

Combine with `LLMChain` for reusable pipelines:

from langchain import LLMChain chain = LLMChain(llm=chat, prompt=chat_prompt) output = chain.run(source="English", target="Chinese", text="I love coding") print(output) # 我喜欢编程。 ``

Integrate agents for autonomous action:

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

llm = OpenAI(temperature=0)
chat_model = ChatOpenAI(temperature=0)
tools = load_tools(["serpapi", "llm-math"], llm=llm)
agent = initialize_agent(tools, chat_model, agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
agent.run("What's the square root of 144? Multiply it by 2.5.")
``

Maintain conversation history using memory:

from langchain.chains import ConversationChain from langchain.memory import ConversationBufferMemory from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, HumanMessagePromptTemplate

prompt = ChatPromptTemplate.from_messages([ SystemMessagePromptTemplate.from_template("You are a friendly AI assistant."), MessagesPlaceholder(variable_name="history"), HumanMessagePromptTemplate.from_template("{input}") ])

memory = ConversationBufferMemory(return_messages=True) conversation = ConversationChain(llm=chat_model, prompt=prompt, memory=memory) print(conversation.predict(input="Hi!")) print(conversation.predict(input="Tell me about yourself.")) ``

LangChain supports diverse use cases including question answering over documents, chatbots, dynamic agent-driven workflows, and data extraction. Its architecture promotes reusability, extensibility, and seamless integration with external systems, making it ideal for scalable, intelligent application development.