LangChain Getting Started

LangChain is a framework that helps us build applications on top of language models. In simple words, LangChain gives us one way of writing code that works with any model provider, cloud or local. The same code that talks to GPT-4 can talk to a local Ollama model by swapping one line. That is exactly why we use it in this series.

In this tutorial, we will learn the installation, the environment setup, and the two ways of calling the model: waiting for the full answer at once, or streaming it word by word.

LangChain wraps ChatOllama, which in turn calls the local Ollama server running on your machine.

Prerequisites: Ollama installed and running locally with qwen3 pulled. See the Ollama Setup Guide. Python 3.10+ and pip available.

How Do We Install LangChain?

Install the Packages

We install the three required packages in one command. Each one has a job: langchain is the framework itself, langchain-ollama provides the ChatOllama integration that talks to our local server, and python-dotenv manages the .env loading we will do next.

pip install langchain langchain-ollama python-dotenv

On Linux/macOS: use pip or pip3 depending on your Python setup.

python -m venv .venv
.venv\Scripts\activate

How Do We Load Environment Variables?

We store API keys and configuration (LangSmith tracing, endpoints, and so on) in a .env file at the root of our project. Why a file instead of hardcoding? Because keys in code get committed and leaked, while a .env file stays on our machine. We load it at the top of our script:

from dotenv import load_dotenv

load_dotenv('.env')

True

Here, the return value of True means at least one variable loaded from the file. If we see False, the .env file was not found. We should check that it exists in the working directory.

LANGCHAIN_API_KEY=your_key_here
LANGCHAIN_TRACING_V2=true
LANGCHAIN_PROJECT=my-project

Why Do We Pull the Model First?

Before running any code, we make sure the target model is available locally. Remember from the Ollama Setup Guide: the weights must be on our disk before anything can run.

ollama pull qwen3

On Linux/macOS: same command; ollama is cross-platform.

How Do We Chat with a Local LLM?

What Is ChatOllama?

ChatOllama is the bridge between LangChain and Ollama. It connects to the Ollama server running at localhost:11434. We set the model name, the temperature, and the maximum output tokens right when we create it:

from langchain_ollama import ChatOllama

llm = ChatOllama(
    base_url="http://localhost:11434",
    model="qwen3",
    temperature=0.8,
    num_predict=256
)

Here, we have created our llm object, and each argument is a decision. Let me tabulate them for your better understanding.

ChatOllama parameters control model choice, sampling behaviour, and context length.

How Do We Invoke the Model?

Now, let's talk to the model. We pass a prompt string to llm.invoke(). It waits until the full answer is ready, and then it returns a message object. We read the generated text from .content:

invoke() blocks until the response is complete; stream() yields tokens in real time.

response = llm.invoke("What is the theory of relativity? Answer in 5 sentences.")
print(response.content)

The theory of relativity, developed by Albert Einstein, consists of two parts: special relativity (1905) and general relativity (1915). Special relativity introduced the idea that the laws of physics are the same for all non-accelerating observers and that the speed of light is constant regardless of the observer's motion. It also established the famous equation E=mc², showing that mass and energy are interchangeable. General relativity extended this to include gravity, describing it not as a force but as the curvature of spacetime caused by mass. Together, they revolutionized our understanding of space, time, and the structure of the universe.

It works. Our Python code just talked to a model running entirely on our own machine. The answer came back as a normal Python object that we can print, store, or pass along.

How Do We Stream the Response?

Waiting for the full answer is fine for short outputs. But for long answers or a chat interface, the user stares at nothing while the model writes. So, here comes llm.stream() to the rescue. It gives us the answer one small chunk at a time instead of all at the end:

for chunk in llm.stream("What is the theory of relativity? Answer in 5 sentences."):
    print(chunk.content, end="", flush=True)

What Is Inside the Response Metadata?

The response object returned by llm.invoke() carries more than the text. It also carries statistics in response_metadata. These numbers tell us how the model performed: how long it took, how many tokens went in, and how many came out. We use this to debug slow calls and measure our prompts:

An AIMessage carries the generated text, metadata stats (timings, token counts), and a tracing run ID.

response.response_metadata

{
  "model": "qwen3",
  "created_at": "2025-10-22T12:16:31.9173234Z",
  "done": true,
  "done_reason": "stop",
  "total_duration": 2630496300,
  "load_duration": 2149414600,
  "prompt_eval_count": 100,
  "prompt_eval_duration": 17446400,
  "eval_count": 140,
  "eval_duration": 397223200,
  "model_name": "qwen3",
  "model_provider": "ollama"
}

Here, we can see the full statistics of our call. Let me explain the key fields.

One field deserves special attention: done_reason. If we ever see our answers cut off mid-sentence, this field tells us why. A value of "length" means the model hit our num_predict limit, and the fix is simply to raise it.

tps = response.response_metadata['eval_count'] / (response.response_metadata['eval_duration'] / 1e9)
print(f"{tps:.1f} tokens/sec")

Quick Reference

Let's put everything we learned in one place for quick copy-paste.

Package Install

pip install langchain langchain-ollama python-dotenv

Minimal Working Example

from dotenv import load_dotenv
from langchain_ollama import ChatOllama

load_dotenv('.env')

llm = ChatOllama(
    model="qwen3",
    temperature=0.8,
    num_predict=256
)

# Single blocking call
response = llm.invoke("Explain transformers in 3 sentences.")
print(response.content)

# Streamed call
for chunk in llm.stream("Explain transformers in 3 sentences."):
    print(chunk.content, end="", flush=True)

ChatOllama Key Parameters

This is how we get started with LangChain. We installed three packages, connected ChatOllama to our local Ollama server, and talked to the model in two ways: invoke() for the full answer at once, and stream() for the answer token by token. Everything we build in this series stands on this one small setup.