Open Source AI Tools for Business 2026: Ollama, LangChain, n8n

Why open source is changing enterprise AI

In 2022, integrating AI into a business almost inevitably meant going through OpenAI or Google. In 2026, the landscape has changed dramatically. Mature open source tools — Ollama, LangChain, n8n — allow you to build AI systems comparable to proprietary solutions, at a fraction of the cost and with full control over your data.

Three structural advantages explain this rapid adoption:

Cost — No per-request billing. An Ollama + LangChain setup on a EUR 200/month server replaces an API bill that could reach EUR 2,000–10,000/month at high volume.
Data privacy — Sensitive data never leaves your infrastructure. Critical for legal, medical, financial sectors and any organization subject to GDPR, HIPAA, or similar data protection regulations.
Flexibility — You choose the model, fine-tune it on your data, deploy it wherever you want. No vendor lock-in.

Key insight: "Open source" does not mean "lower quality." In 2026, Llama 3.3 70B and Mistral Large 2 compete with GPT-4o on most business tasks. The performance gap has narrowed considerably.

Ollama: run LLMs locally

Ollama is a tool that lets you download and run large language models directly on your machine or servers, without complex configuration. One command to install, one command to launch a model.

Installation and first model

# Installation (macOS / Linux)
curl -fsSL https://ollama.com/install.sh | sh

# Download and run Llama 3.2 (3B — fast, lightweight)
ollama run llama3.2

# For more complex tasks: Llama 3.3 70B (requires 40GB+ VRAM)
ollama pull llama3.3:70b

# Check locally available models
ollama list

Using Ollama from Python

Ollama exposes an OpenAI-compatible REST API. You can use it with the native Python SDK or directly via requests:

# pip install ollama
import ollama

# Simple inference request
response = ollama.chat(
    model='llama3.2',
    messages=[{
        'role': 'user',
        'content': (
            'Analyze this customer review and identify the key points: '
            '"The product is excellent but the delivery was slow '
            'and the packaging was damaged."'
        )
    }]
)
print(response['message']['content'])
# Key points: Product quality (positive), Delivery time (negative),
#             Packaging condition (negative)

# Streaming for user-facing interfaces
for chunk in ollama.chat(
    model='llama3.2',
    messages=[{'role': 'user', 'content': 'Draft a professional follow-up email'}],
    stream=True
):
    print(chunk['message']['content'], end='', flush=True)

Recommended models by use case

Use Case	Recommended Model	VRAM Required	Speed
Classification, extraction	Phi-3 Mini (3.8B)	4 GB	Very fast
Chatbot, document Q&A	Llama 3.2 (7B)	8 GB	Fast
Analysis, long generation	Mistral Nemo (12B)	16 GB	Medium
Complex reasoning, code	Llama 3.3 (70B)	40 GB	Slow
Embeddings (RAG)	nomic-embed-text	1 GB	Very fast

For businesses without a GPU: Run Ollama on a cloud instance. AWS g4dn.xlarge (NVIDIA T4, 16GB VRAM) costs approximately EUR 0.53/hour on-demand or EUR 0.16/hour spot. For low-volume workloads, spot instances can reduce inference costs to near zero.

LangChain: orchestrate your AI pipelines

LangChain is the most widely adopted Python (and JavaScript) framework for building AI applications. It provides abstractions for connecting LLMs to databases, APIs, external tools, and for orchestrating complex sequences of calls.

RAG pipeline with Ollama — complete example

The most common enterprise use case: a chatbot that answers questions about your internal documents (contracts, HR policies, product documentation).

# pip install langchain langchain-community langchain-ollama chromadb pypdf
from langchain_ollama import OllamaLLM, OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA

# 1. Load your documents (PDF, DOCX, TXT...)
loader = PyPDFLoader("hr-policy-2026.pdf")
documents = loader.load()

# 2. Split into chunks (improves retrieval precision)
splitter = RecursiveCharacterTextSplitter(
    chunk_size=800,
    chunk_overlap=100,
    separators=["

", "
", ".", " "]
)
chunks = splitter.split_documents(documents)

# 3. Create embeddings and store in ChromaDB (persistent)
embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma.from_documents(
    chunks,
    embeddings,
    persist_directory="./chroma_db"  # Persists across restarts
)

# 4. Build the RAG chain
llm = OllamaLLM(model="llama3.2", temperature=0.1)
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
    return_source_documents=True
)

# 5. Query
result = qa_chain.invoke({
    "query": "What is the remote work policy?"
})
print(result["result"])
# → "According to our 2026 HR policy, employees may work remotely
#    up to 3 days per week with manager approval..."

# Source pages used
for doc in result["source_documents"]:
    print(f"Source: page {doc.metadata['page']}")

Tip: Use temperature=0.1 for factual answers grounded in your documents. Low temperature reduces hallucinations and keeps the model anchored to retrieved content rather than generating from its training data.

LangChain agents with tools

Beyond RAG, LangChain allows you to build agents capable of using tools (web search, calculations, internal APIs) to complete multi-step tasks autonomously:

from langchain_ollama import OllamaLLM
from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import tool
from langchain import hub

# Define custom business tools
@tool
def get_product_stock(product_id: str) -> str:
    """Check the current stock level for a product."""
    # Replace with your actual database call
    stocks = {"PROD-001": 45, "PROD-002": 0, "PROD-003": 120}
    qty = stocks.get(product_id, -1)
    if qty == -1:
        return f"Product {product_id} not found"
    return f"Stock for {product_id}: {qty} units"

@tool
def calculate_delivery_date(warehouse: str, destination: str) -> str:
    """Estimate delivery date from a warehouse to a destination."""
    delays = {"New York": 1, "Chicago": 2, "Los Angeles": 3, "default": 5}
    days = delays.get(destination, delays["default"])
    return f"Estimated delivery from {warehouse} to {destination}: {days} business days"

# Build the agent
llm = OllamaLLM(model="llama3.2")
tools = [get_product_stock, calculate_delivery_date]
prompt = hub.pull("hwchase17/react")

agent = create_react_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# The agent decides which tools to use
result = executor.invoke({
    "input": "Check if PROD-001 is in stock and give the delivery date to Chicago"
})
print(result["output"])
# → "PROD-001 is in stock (45 units). Delivery to Chicago: 2 business days."

n8n: automate your AI workflows without code

n8n is an open source automation platform (alternative to Zapier or Make) that stands out for its native AI nodes — calls to Ollama, LangChain, or LLM APIs — inside visual workflows. It is the "glue" that connects your AI tools to your existing ecosystem (CRM, ERP, email, Slack...).

2-minute installation

# Option 1: Docker (recommended for production)
docker run -d \
  --name n8n \
  -p 5678:5678 \
  -v ~/.n8n:/home/node/.n8n \
  -e N8N_BASIC_AUTH_ACTIVE=true \
  -e N8N_BASIC_AUTH_USER=admin \
  -e N8N_BASIC_AUTH_PASSWORD=your_strong_password \
  n8nio/n8n

# Access the UI at: http://localhost:5678

# Option 2: npm (local development)
npm install -g n8n
n8n start

Example workflow: automated inbound email processing

Here is a real n8n workflow that analyzes each incoming email with Ollama, categorizes it, and creates a task in your CRM:

Trigger — Incoming email (Gmail, Outlook, IMAP)
HTTP Request node — Call to your local Ollama API to analyze the content
Switch node — Route by category (urgent / sales / support)
CRM node — Create a task in HubSpot / Salesforce / Pipedrive
Slack node — Notify the relevant team

# Call to Ollama from an n8n HTTP Request node
# URL: http://ollama:11434/api/generate (if Ollama runs in Docker)
# Method: POST
# Body (JSON):
{
  "model": "llama3.2",
  "prompt": "Categorize this email as: URGENT, SALES, SUPPORT, or SPAM. Email: {{ $json.body }}. Reply with just the category.",
  "stream": false
}

# The response is available in the next node via:
# {{ $json.response }}

n8n can also trigger Python scripts, which lets you integrate your LangChain chains directly into a visual workflow:

# "Execute Command" node in n8n
# Triggers your Python script with workflow data
python3 /opt/scripts/process_email.py \
  --subject "{{ $json.subject }}" \
  --body "{{ $json.body }}" \
  --sender "{{ $json.from }}"

# The script returns JSON that n8n can use in subsequent nodes

n8n vs Zapier vs Make — quick comparison

Feature	n8n	Zapier	Make
Pricing model	Free self-hosted	Per task (EUR 20–150/mo)	Per operation (EUR 9–16/mo)
Data control	Full (self-hosted)	SaaS only	SaaS only
AI integration	Native (Ollama, OpenAI, Claude)	Limited	Via HTTP
Custom code	JavaScript + Python exec	JavaScript only	No
GDPR compliance	Full (self-hosted EU)	Partial	Partial

Combined architecture: a concrete example

Here is a real architecture deployed by a 50-person company to automate the processing of client documents (invoices, contracts, quotes):

# Python script orchestrating Ollama + ChromaDB
# Triggered by n8n on each new document

import ollama
import chromadb
from pathlib import Path
from datetime import datetime
import json

# Persistent ChromaDB client
chroma_client = chromadb.PersistentClient(path="/data/company_docs")
collection = chroma_client.get_or_create_collection(
    name="documents",
    metadata={"hnsw:space": "cosine"}
)

def extract_and_store_document(file_path: str, doc_id: str) -> dict:
    """
    Extracts key info from a document and stores it for future search.
    Handles plain text files. For PDFs, pre-process with PyPDF2.
    """
    text = Path(file_path).read_text(encoding="utf-8")

    # Structured extraction via Ollama
    extraction_prompt = f"""Extract from this document:
1. Type (INVOICE/CONTRACT/QUOTE/OTHER)
2. Total amount in EUR (0 if absent)
3. Document date (YYYY-MM-DD format)
4. Client or supplier name
5. One-sentence summary

Reply with valid JSON only.

Document:
{text[:3000]}"""

    response = ollama.chat(
        model='llama3.2',
        messages=[{
            'role': 'user',
            'content': extraction_prompt
        }],
        format='json'  # Forces JSON output
    )

    metadata = json.loads(response['message']['content'])
    metadata['processed_at'] = datetime.now().isoformat()
    metadata['file_path'] = file_path

    # Embeddings via Ollama (lightweight model, ~100ms)
    embedding_response = ollama.embeddings(
        model='nomic-embed-text',
        prompt=text[:2000]
    )

    # Store in ChromaDB
    collection.add(
        documents=[text[:5000]],
        embeddings=[embedding_response['embedding']],
        metadatas=[metadata],
        ids=[doc_id]
    )

    return metadata

# Example usage
result = extract_and_store_document(
    file_path="/data/uploads/invoice_2026_04_001.txt",
    doc_id="INV-2026-04-001"
)
print(json.dumps(result, indent=2))
# {
#   "type": "INVOICE",
#   "amount": 4250.00,
#   "date": "2026-04-03",
#   "client": "Acme Corp",
#   "summary": "Invoice for digital transformation consulting services",
#   "processed_at": "2026-04-06T09:14:32.451Z"
# }

Production architecture tip: Add a message queue (Redis Queue or AWS SQS) between n8n and your Python script to process documents in parallel without overloading Ollama. n8n handles ingestion, the queue handles load smoothing. This pattern supports thousands of documents per day on a single GPU server.

Cost comparison: open source vs proprietary APIs

Concrete example: a team processing 10,000 documents per month, each requiring approximately 2,000 input tokens and 500 output tokens.

Solution	Monthly Cost	Annual Cost	Data Leaves Infrastructure
OpenAI GPT-4o	EUR 275	EUR 3,300	Yes
Anthropic Claude Sonnet	EUR 230	EUR 2,760	Yes
Ollama (AWS EC2 g4dn.xlarge)	EUR 135	EUR 1,620	No
Ollama (dedicated server)	EUR 40–80	EUR 480–960	No

The cost savings are significant, but the real advantage is data privacy. For law firms, clinics, banks, or any organization processing sensitive data, keeping data off third-party servers is not an optional benefit — it is a legal and compliance requirement.

Hybrid approach: Many businesses run Ollama for routine, high-volume tasks (classification, extraction, summarization) and use Claude or GPT-4 via API for complex reasoning tasks (10–15% of volume). This "tiered LLM" architecture typically reduces total AI costs by 60–80% vs pure API usage, while maintaining quality on critical tasks.

Getting started and next steps

Mastering these three tools together takes approximately 20–30 hours of hands-on practice for a technical profile. The steepest learning curve is LangChain — the LCEL (LangChain Expression Language) abstractions require some adaptation time.

Recommended learning path

Week 1: Install Ollama, run your first model locally, call it from Python. Build a simple document Q&A script using LangChain + ChromaDB.
Week 2: Install n8n with Docker. Build your first workflow: email trigger → Ollama categorization → Slack notification. Measure latency and tune your prompt.
Week 3: Combine all three. Deploy the document processing architecture from this article. Add monitoring (Prometheus + Grafana) to track throughput and GPU usage.

Key resources

Ollama model library — Browse all available models with size, speed, and benchmark comparisons
LangChain documentation — Official Python docs with LCEL, RAG, and agents guides
n8n documentation — Complete workflow reference with node catalog
LangChain & LangGraph practical guide — Deep dive into LCEL patterns, advanced RAG, and multi-step agents
Ollama in production 2026 — Docker GPU setup, benchmarks, scaling patterns

Our AI Agents training covers LangChain and LangGraph in depth, with hands-on exercises using Ollama. For teams looking to adopt n8n without writing code, the No-Code AI Automation training is the ideal entry point. OPCO funding available for both.

Frequently Asked Questions

Is Ollama production-ready for a business environment?

Yes, provided you size the infrastructure correctly. Ollama runs reliably in production on GPU servers (NVIDIA A10 or higher for 7B–13B models). Most businesses deploy Ollama on AWS EC2 (g4dn or g5 instances), GCP, or Azure. For low-to-medium volumes (< 1,000 requests/day), a single dedicated server is sufficient. Beyond that, combine Ollama with a load balancer and multiple instances.

Is LangChain still relevant in 2026 compared to LlamaIndex and Haystack?

LangChain remains the most widely adopted framework (50M+ downloads/month) with the richest integration ecosystem. LlamaIndex excels at pure RAG pipelines. Haystack is preferred for enterprise semantic search with Elasticsearch. For most business use cases (chatbots, RAG, agents), LangChain + LangGraph is the most pragmatic choice in 2026.

Can I run RAG with Ollama without a GPU?

Yes, but performance is reduced. CPU-only setups run models like Phi-3 Mini (3.8B) or Llama 3.2 3B acceptably (3–8 seconds per response). For RAG specifically, the embedding step (nomic-embed-text) is lightweight and runs well on CPU. If GPU is not an option, consider a cloud spot instance with GPU for batch processing workloads.

Is n8n free for enterprise use?

n8n offers three options: self-hosted Community Edition (completely free, open source), Cloud Starter (EUR 20/month, 2,500 executions), and Enterprise (custom pricing, SLA, SSO, audit logs). For most SMBs, the self-hosted version on a EUR 10–20/month VPS covers all needs. The code is on GitHub under an Apache 2.0 license with a Sustainable Use exception.

How does open source AI compare to proprietary APIs for GDPR compliance?

Self-hosted open source tools (Ollama, ChromaDB, n8n) are strongly preferred for GDPR compliance: sensitive data never leaves your infrastructure, you control retention and deletion, and there is no third-party data processing agreement required. For sectors like healthcare, legal, and finance, this is not optional — it is a legal requirement. Ollama hosted in the EU combined with ChromaDB gives you full data sovereignty.

Top Open Source AI Tools for Business: Ollama, LangChain, and n8n in 2026