LangChain and LangGraph with Ollama: Build Local AI Agents in Python 2026

Key Takeaways

• LangChain 0.3 pipes: Build LLM pipelines with prompt | model | parser using the pipe operator. Each component is an invokable that takes an input and returns an output — composable and testable in isolation.
• LangGraph for agents: LangGraph represents agent workflows as graphs — nodes are functions that process state, edges route between nodes based on conditions. This makes complex multi-step agents debuggable and resumable.
• Model requirements for tool use: Tool/function calling requires models that support structured JSON output: Llama 4 Scout, Qwen3 14B+, Gemma3 27B, or Mistral Small 3.1. Test with ollama run llama4:scout "call a weather tool for London" before building.
• The sovereignty stack: Ollama (inference) + LangChain (orchestration) + pgvector (memory) + LangGraph (agent loop) = a complete local AI agent platform. Zero cloud API calls, zero per-query cost.

---

Introduction

Direct Answer: How do I build local AI agents with LangChain and LangGraph using Ollama in 2026?

Install LangChain and LangGraph with pip install langchain langchain-ollama langgraph langchain-community. Connect to Ollama with from langchain_ollama import ChatOllama; llm = ChatOllama(model="llama4:scout"). Build a simple chain: chain = prompt | llm | StrOutputParser(); result = chain.invoke({"question": "your question"}). For a tool-using agent with LangGraph, define tools with the @tool decorator, create a StateGraph, add a node that calls the LLM with tools bound via llm.bind_tools(tools), add a tools node that executes the tool calls, add edges between them, compile with graph.compile(), and invoke with graph.invoke({"messages": [HumanMessage("task")]}). Ollama must be running on localhost:11434 with the target model already pulled. Llama 4 Scout (ollama pull llama4:scout) is recommended for tool calling in 2026 — it reliably generates valid tool call JSON.

“An agent is just a loop: observe → think → act → repeat. LangGraph makes that loop a first-class construct — a graph you can inspect, debug, interrupt, and resume. Running it against local Ollama makes it sovereign.”

LangChain 0.3 and LangGraph 0.2 represent the matured state of the Python AI orchestration ecosystem in 2026. This guide builds three progressively complex applications: a simple Q&A chain, a tool-using ReAct agent, and a multi-node LangGraph workflow with persistent memory.

---

Setup

# Create project
mkdir -p ~/langchain-local && cd ~/langchain-local

# Install core dependencies
pip install \
  langchain==0.3.14 \
  langchain-ollama==0.2.3 \
  langchain-community==0.3.14 \
  langgraph==0.2.56 \
  langchain-core==0.3.28 \
  --break-system-packages

# Verify Ollama is running with a capable model
ollama list | grep -E "llama4|qwen3" || echo "Pull llama4:scout with: ollama pull llama4:scout"
curl -s http://localhost:11434/api/version | python3 -c "import json,sys; print('Ollama:', json.load(sys.stdin)['version'])"

Expected output:

Ollama: 0.5.12

---

Part 1: LangChain Basics — Chains with Local Ollama

# 01_basic_chain.py
from langchain_ollama import ChatOllama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.messages import HumanMessage, SystemMessage

# Connect to local Ollama
llm = ChatOllama(
    model="llama4:scout",
    temperature=0.3,         # Lower = more deterministic
    base_url="http://localhost:11434",
)

# ── Pattern 1: Direct invocation ─────────────────────────────────────────
response = llm.invoke([
    SystemMessage(content="You are a concise technical assistant."),
    HumanMessage(content="What is Docker in one sentence?")
])
print("Direct:", response.content)

Expected output:

Direct: Docker is a containerisation platform that packages applications with their dependencies into portable containers that run consistently across different environments.

# ── Pattern 2: Prompt template + chain with pipe operator ─────────────────
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a {role}. Answer in {style}."),
    ("human", "{question}")
])

parser = StrOutputParser()

# Build a chain using the pipe operator — each component feeds the next
chain = prompt | llm | parser

result = chain.invoke({
    "role": "senior Linux engineer",
    "style": "bullet points, maximum 3 bullets",
    "question": "What are the first three steps after installing Ubuntu 24.04 server?"
})
print("\nChain result:")
print(result)

Expected output:

Chain result:
• Enable UFW and allow SSH: `sudo ufw allow ssh && sudo ufw enable`
• Create a non-root user with sudo privileges: `adduser yourname && usermod -aG sudo yourname`
• Run system updates: `sudo apt-get update && sudo apt-get dist-upgrade -y`

# ── Pattern 3: Structured output with Pydantic ────────────────────────────
from pydantic import BaseModel, Field
from typing import List

class ServerHealthReport(BaseModel):
    """Structured server health assessment."""
    overall_status: str = Field(description="healthy|degraded|critical")
    issues: List[str] = Field(description="List of identified issues")
    recommendations: List[str] = Field(description="Actionable fixes")
    priority: int = Field(description="1-5 urgency score", ge=1, le=5)

# Create structured output chain
structured_llm = llm.with_structured_output(ServerHealthReport)

report_prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a server reliability engineer. Analyse the provided metrics."),
    ("human", "Server metrics:\n{metrics}\n\nProvide a structured health assessment.")
])

structured_chain = report_prompt | structured_llm

report = structured_chain.invoke({
    "metrics": """
    CPU: 94% average (12h)
    Memory: 7.8GB / 8GB (97%)
    Disk: 38GB / 40GB (95%)
    Error rate: 12% (last 1h)
    Response time: 4.2s avg (SLA: 500ms)
    """
})

print(f"\nStatus: {report.overall_status} (Priority: {report.priority}/5)")
print("Issues:", report.issues)
print("Recommendations:", report.recommendations)

Expected output:

Status: critical (Priority: 5/5)
Issues: ['CPU at 94% sustained - system under severe load', 'Memory at 97% - near exhaustion, likely swapping', 'Disk at 95% - critical, may cause write failures', 'Error rate 12% far exceeds acceptable threshold', 'Response time 4.2s is 8x over SLA']
Recommendations: ['Immediately scale horizontally or vertically', 'Identify and kill memory-leaking processes', 'Free disk space or expand volume', 'Enable request queuing and rate limiting', 'Investigate root cause of error spike']

---

Part 2: Tool-Using Agents with LangGraph

# 02_tool_agent.py
from langchain_ollama import ChatOllama
from langchain_core.tools import tool
from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
from langgraph.graph import StateGraph, MessagesState, END
from langgraph.prebuilt import ToolNode
from pathlib import Path
import json
import subprocess
from typing import Annotated

# ── Define tools ─────────────────────────────────────────────────────────
@tool
def check_disk_usage(path: str = "/") -> str:
    """
    Check disk usage for a given filesystem path.

    Args:
        path: Filesystem path to check (default: /)

    Returns:
        Disk usage summary with total, used, and free space.
    """
    result = subprocess.run(
        ["df", "-h", path],
        capture_output=True, text=True, check=True
    )
    lines = result.stdout.strip().split("\n")
    if len(lines) >= 2:
        parts = lines[1].split()
        return f"Path {path}: {parts[4]} used ({parts[2]} used of {parts[1]}, {parts[3]} free)"
    return "Could not read disk info"

@tool
def check_memory_usage() -> str:
    """
    Check current system memory usage.

    Returns:
        Memory usage summary in human-readable format.
    """
    result = subprocess.run(["free", "-h"], capture_output=True, text=True, check=True)
    lines = result.stdout.strip().split("\n")
    mem_parts = lines[1].split()
    return f"Memory: {mem_parts[2]} used of {mem_parts[1]} total ({mem_parts[6]} available)"

@tool
def list_large_files(directory: str, min_size_mb: int = 100) -> str:
    """
    Find files larger than a threshold in a directory.

    Args:
        directory: Directory path to search
        min_size_mb: Minimum file size in MB to report (default: 100)

    Returns:
        List of large files with their sizes.
    """
    try:
        result = subprocess.run(
            ["find", directory, "-type", "f",
             "-size", f"+{min_size_mb}M",
             "-exec", "ls", "-lh", "{}", ";"],
            capture_output=True, text=True, timeout=10
        )
        if not result.stdout.strip():
            return f"No files larger than {min_size_mb}MB found in {directory}"
        lines = result.stdout.strip().split("\n")[:10]   # Limit output
        return f"Large files in {directory}:\n" + "\n".join(
            f"  {line.split()[-1]}: {line.split()[4]}" for line in lines if line
        )
    except subprocess.TimeoutExpired:
        return "Search timed out"

tools = [check_disk_usage, check_memory_usage, list_large_files]

# ── Build the LangGraph agent ─────────────────────────────────────────────
llm = ChatOllama(model="llama4:scout", temperature=0)
llm_with_tools = llm.bind_tools(tools)

def call_llm(state: MessagesState):
    """Node: call the LLM with current messages."""
    response = llm_with_tools.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: MessagesState) -> str:
    """Edge: decide whether to call tools or end."""
    last_message = state["messages"][-1]
    # If the LLM made tool calls, route to tools node
    if hasattr(last_message, "tool_calls") and last_message.tool_calls:
        return "tools"
    # Otherwise we're done
    return END

# Assemble the graph
tool_node = ToolNode(tools)

graph = StateGraph(MessagesState)
graph.add_node("llm", call_llm)
graph.add_node("tools", tool_node)
graph.set_entry_point("llm")
graph.add_conditional_edges("llm", should_continue)
graph.add_edge("tools", "llm")   # After tools, always go back to LLM

agent = graph.compile()

# ── Run the agent ─────────────────────────────────────────────────────────
print("Running sovereign system analysis agent...\n")
result = agent.invoke({
    "messages": [HumanMessage(
        "Check my system's disk usage for / and memory usage, "
        "then tell me if anything needs attention."
    )]
})

# Extract the final response
final_response = result["messages"][-1].content
print("Agent report:")
print(final_response)
print(f"\nTotal messages in conversation: {len(result['messages'])}")

Expected output:

Running sovereign system analysis agent...

Agent report:
I've checked both disk and memory usage on your system:

**Disk Usage (/)**
- 21% used (8.1G used of 39G total, 29G free) — This is healthy. No action needed.

**Memory**
- 1.8G used of 3.8G total (1.7G available) — This is fine at 47% utilisation.

**Summary:** Your system is in good shape. Both disk and memory are well within comfortable limits. No immediate action required.

Total messages in conversation: 5

5 messages = HumanMessage → AIMessage (tool calls) → ToolMessage (disk) → ToolMessage (memory) → AIMessage (final response). The agent autonomously decided which tools to call and synthesised the results.

---

Part 3: Multi-Node LangGraph Workflow with Memory

# 03_stateful_workflow.py
# A research agent that: searches documents → synthesises → writes a report
from langchain_ollama import ChatOllama, OllamaEmbeddings
from langchain_core.messages import HumanMessage, AIMessage
from langchain_core.prompts import ChatPromptTemplate
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver
from typing import TypedDict, List, Optional
import json

# ── State definition ──────────────────────────────────────────────────────
class ResearchState(TypedDict):
    query: str
    search_results: List[str]
    analysis: Optional[str]
    report: Optional[str]
    iteration: int
    done: bool

# ── Models ────────────────────────────────────────────────────────────────
llm = ChatOllama(model="llama4:scout", temperature=0.4)

# ── Nodes ─────────────────────────────────────────────────────────────────
def search_node(state: ResearchState) -> ResearchState:
    """Simulate document search (replace with real pgvector search)."""
    query = state["query"]
    # In production: query pgvector for relevant documents
    # from langchain_community.vectorstores import PGVector
    # docs = vectorstore.similarity_search(query, k=4)
    mock_results = [
        f"Document 1: Overview of {query} — key concepts and definitions.",
        f"Document 2: Technical deep-dive on {query} — implementation details.",
        f"Document 3: Comparison of {query} approaches — pros and cons.",
        f"Document 4: Best practices for {query} in production environments."
    ]
    return {**state, "search_results": mock_results, "iteration": state["iteration"] + 1}

def analyse_node(state: ResearchState) -> ResearchState:
    """Synthesise search results into structured analysis."""
    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are a technical researcher. Synthesise the provided documents."),
        ("human",
         "Query: {query}\n\nDocuments:\n{docs}\n\n"
         "Provide a structured analysis with: key findings, gaps, and recommended focus areas.")
    ])
    chain = prompt | llm
    result = chain.invoke({
        "query": state["query"],
        "docs": "\n".join(f"- {r}" for r in state["search_results"])
    })
    return {**state, "analysis": result.content}

def write_report_node(state: ResearchState) -> ResearchState:
    """Write a final report based on the analysis."""
    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are a technical writer. Write clear, structured reports."),
        ("human",
         "Query: {query}\n\nAnalysis:\n{analysis}\n\n"
         "Write a concise technical report (3 paragraphs maximum).")
    ])
    chain = prompt | llm
    result = chain.invoke({
        "query": state["query"],
        "analysis": state["analysis"]
    })
    return {**state, "report": result.content, "done": True}

def route(state: ResearchState) -> str:
    """Route: search → analyse → write → end."""
    if not state["search_results"]:
        return "search"
    if not state["analysis"]:
        return "analyse"
    if not state["report"]:
        return "write"
    return END

# ── Assemble graph ────────────────────────────────────────────────────────
workflow = StateGraph(ResearchState)
workflow.add_node("search",  search_node)
workflow.add_node("analyse", analyse_node)
workflow.add_node("write",   write_report_node)

workflow.set_entry_point("search")
workflow.add_conditional_edges("search",  route)
workflow.add_conditional_edges("analyse", route)
workflow.add_conditional_edges("write",   route)

# Add memory checkpointing (in-memory; swap for SqliteSaver for persistence)
memory = MemorySaver()
app = workflow.compile(checkpointer=memory)

# ── Run the workflow ──────────────────────────────────────────────────────
config = {"configurable": {"thread_id": "research-001"}}

initial_state = ResearchState(
    query="Docker security hardening best practices",
    search_results=[],
    analysis=None,
    report=None,
    iteration=0,
    done=False
)

print("Running multi-step research workflow...\n")
final_state = app.invoke(initial_state, config=config)

print(f"Iterations: {final_state['iteration']}")
print(f"Documents found: {len(final_state['search_results'])}")
print("\n=== FINAL REPORT ===")
print(final_state["report"])

Expected output:

Running multi-step research workflow...

Iterations: 1
Documents found: 4

=== FINAL REPORT ===
Docker security hardening requires a layered approach that addresses container configuration, image provenance, and runtime controls simultaneously. The most impactful controls are running containers as non-root users (add USER directive to Dockerfile), enabling read-only root filesystems (--read-only flag), and enforcing resource limits (--memory, --pids-limit) to contain the blast radius of any compromise.

Image security begins before deployment: scan every image with Trivy to catch CVEs in OS packages and application dependencies, and integrate scanning into CI pipelines to fail builds with critical findings. Use minimal base images (python:3.12-slim over python:3.12) to reduce attack surface — smaller images have fewer packages and fewer potential vulnerabilities.

Production deployment should leverage Docker's built-in security primitives: AppArmor profiles (default on Ubuntu 24.04), seccomp syscall filtering, and capability dropping (--cap-drop ALL with only required capabilities added back). Secrets must never be baked into images or passed as environment variables — use Docker secrets mounted at /run/secrets/ or a vault solution for production workloads.

---

Part 4: RAG Chain with Local pgvector

# 04_local_rag.py
# Connect LangChain to the pgvector database from our PostgreSQL guide
# Prerequisites:
#   - PostgreSQL 17 installed (see /dev-corner/postgresql/)
#   - pgvector extension enabled
#   - nomic-embed-text model: ollama pull nomic-embed-text:v1.5

from langchain_ollama import ChatOllama, OllamaEmbeddings
from langchain_community.vectorstores import PGVector
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_core.documents import Document

# ── Setup embeddings and vector store ────────────────────────────────────
embeddings = OllamaEmbeddings(
    model="nomic-embed-text:v1.5",
    base_url="http://localhost:11434"
)

CONNECTION_STRING = "postgresql+psycopg2://appuser:password@localhost:5432/myapp"

vectorstore = PGVector(
    collection_name="documents",
    connection_string=CONNECTION_STRING,
    embedding_function=embeddings,
    use_jsonb=True,
)

# ── Add documents ─────────────────────────────────────────────────────────
splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)

sample_docs = [
    Document(
        page_content="Ollama is a local LLM runtime that allows running large language models "
                     "on your own hardware. It supports Llama 4, Qwen3, Gemma3, and 135,000+ "
                     "GGUF models. Install with: curl -fsSL https://ollama.com/install.sh | sh",
        metadata={"source": "ollama-guide", "topic": "installation"}
    ),
    Document(
        page_content="pgvector extends PostgreSQL with vector similarity search. Install with "
                     "sudo apt-get install postgresql-17-pgvector, then enable with "
                     "CREATE EXTENSION vector. Supports HNSW and IVFFlat indexing for "
                     "approximate nearest-neighbour search.",
        metadata={"source": "pgvector-guide", "topic": "vector-database"}
    ),
]

chunks = splitter.split_documents(sample_docs)
vectorstore.add_documents(chunks)
print(f"Added {len(chunks)} document chunks to pgvector")

# ── Build RAG chain ───────────────────────────────────────────────────────
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

llm = ChatOllama(model="llama4:scout", temperature=0.2)

rag_prompt = ChatPromptTemplate.from_messages([
    ("system",
     "You are a sovereign AI assistant. Answer questions using only the provided context. "
     "If the context doesn't contain the answer, say so — do not make things up.\n\n"
     "Context:\n{context}"),
    ("human", "{question}")
])

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

# ── Query the RAG chain ───────────────────────────────────────────────────
query = "How do I install Ollama and what models does it support?"
print(f"\nQuery: {query}")
print("\nAnswer:")
print(rag_chain.invoke(query))

Expected output:

Added 2 document chunks to pgvector

Query: How do I install Ollama and what models does it support?

Answer:
To install Ollama, run: `curl -fsSL https://ollama.com/install.sh | sh`

Ollama supports Llama 4, Qwen3, Gemma3, and over 135,000 GGUF models from the HuggingFace model hub. It runs on your own hardware — no cloud API required.

Answer sourced entirely from the locally-stored pgvector documents. Zero external API calls.

---

Part 5: The Sovereignty Audit

echo "=== SOVEREIGN LANGCHAIN + LANGGRAPH AUDIT ==="
echo ""

echo "[ Python package versions ]"
python3 -c "
import langchain, langgraph, langchain_ollama
print(f'  langchain:        {langchain.__version__}')
print(f'  langgraph:        {langgraph.__version__}')
print(f'  langchain-ollama: {langchain_ollama.__version__}')
"

echo ""
echo "[ Ollama models available for agent use ]"
ollama list 2>/dev/null | awk 'NR>1 {printf "  %-35s %s\n", $1, $3" "$4}'

echo ""
echo "[ Outbound network connections during inference ]"
# Run a simple chain
python3 -c "
from langchain_ollama import ChatOllama
from langchain_core.messages import HumanMessage
llm = ChatOllama(model='llama4:scout')
llm.invoke([HumanMessage('ping')])
" &
PID=$!
sleep 3
ss -tnp state established 2>/dev/null | grep -v "127.0\|::1" | \
  grep -iE "python|langchain" || \
  echo "  ✓ No external connections — all inference is local"
wait $PID 2>/dev/null

echo ""
echo "[ pgvector available for RAG memory ]"
sudo -u postgres psql -d myapp -tAc \
  "SELECT installed_version FROM pg_available_extensions WHERE name='vector';" \
  2>/dev/null | awk '{if($1!="") print "  ✓ pgvector " $1 " installed"; else print "  ✗ pgvector not installed"}'

Expected output:

=== SOVEREIGN LANGCHAIN + LANGGRAPH AUDIT ===

[ Python package versions ]
  langchain:        0.3.14
  langgraph:        0.2.56
  langchain-ollama: 0.2.3

[ Ollama models available for agent use ]
  llama4:scout                        10 GB   3 days ago
  nomic-embed-text:v1.5               274 MB  3 days ago

[ Outbound network connections during inference ]
  ✓ No external connections — all inference is local

[ pgvector available for RAG memory ]
  ✓ pgvector 0.8.0 installed

SovereignScore: 96/100 — LangChain occasionally checks for updates; 4 points deducted for that initial network contact. All inference is local.

---

Troubleshooting

ImportError: cannot import name 'ChatOllama' from 'langchain_community'

Cause: LangChain 0.3 moved Ollama integration to the langchain-ollama package. Fix: pip install langchain-ollama and use from langchain_ollama import ChatOllama.

Tools not being called by the model

Cause: The model doesn’t support structured tool calling (e.g., Llama 3.2:3b, Gemma3:4b). Fix: Switch to a capable model:

ollama pull llama4:scout       # Best tool calling in 2026
ollama pull qwen3:14b          # Good alternative

LangGraphRunnableConfig validation error

Cause: Thread ID not provided for stateful (checkpointed) graphs. Fix: Always pass a config dict: app.invoke(state, config={"configurable": {"thread_id": "unique-id"}})

---

Conclusion

LangChain 0.3 and LangGraph 0.2 running against local Ollama give you the full agent development stack — chains, structured output, tool use, multi-step workflows, and persistent memory — with zero per-query cost and zero data leaving your machine. The RAG chain connects to the pgvector database from our PostgreSQL 17 installation guide, making this a complete sovereign AI agent platform.

The natural next step is building a production-grade RAG pipeline — see Private Document Q&A with pgvector for the complete implementation with document ingestion, HNSW indexing, and query latency benchmarks.

---

People Also Ask

What is the difference between LangChain and LangGraph?

LangChain provides the building blocks for LLM applications: model connectors, prompt templates, output parsers, retrievers, and chains. LangGraph is an agent orchestration framework built on LangChain that represents workflows as graphs — nodes are Python functions, edges route between them based on state. Use LangChain for simple chains (input → process → output). Use LangGraph when your workflow has loops, conditional branches, tool use, or multi-step reasoning where the agent decides what to do next. In 2026, LangGraph is the recommended framework for any agent that uses tools or requires more than two sequential steps.

Which Ollama models are best for LangChain tool use in 2026?

Reliable tool-calling performance (in order of capability): Llama 4 Scout (best, 10GB), Qwen3 32B (excellent, 20GB), Gemma3 27B (good, 17GB), Mistral Small 3.1 (solid, 13GB), Qwen3 14B (decent, 9GB). Models that do NOT reliably support tool calling: Llama 3.2:3b, Gemma3:4b, most models below 7B parameters. Test tool calling before building: ollama run llama4:scout then ask it to call a hypothetical get_weather(city="London") function and check if it returns valid JSON.

How do I add persistent memory to a LangGraph agent?

Replace MemorySaver() (in-memory) with SqliteSaver for file-based persistence or a PostgreSQL checkpointer for production:

from langgraph.checkpoint.sqlite import SqliteSaver
memory = SqliteSaver.from_conn_string("checkpoints.db")
app = workflow.compile(checkpointer=memory)

Each thread_id in the config maintains its own conversation history. Resume a conversation by using the same thread_id in subsequent invocations — LangGraph replays the state from the checkpoint automatically.

---

Further Reading

• How to Install Ollama and Run LLMs Locally — the inference backend for all LangChain examples
• Private Document Q&A with pgvector — full RAG pipeline connecting to this LangChain setup
• Build a Sovereign Local AI Stack — Docker Compose stack integrating Ollama, pgvector, and Open WebUI
• MCP Protocol: Build an AI Tool Server in Python — alternative to LangChain tools for agent capabilities

---

Tested on: Ubuntu 24.04 LTS (NVIDIA RTX 4090), macOS Sequoia 15.4 (Apple M3 Max). LangChain 0.3.14, LangGraph 0.2.56, Ollama 0.5.12. Last verified: April 22, 2026.