Cloud API Request:
  Client → Internet → API Gateway → Load Balancer → Model Server → Response
  Total latency: 200-800ms (varies by location)

Local Inference:
  Client → Local Model → Response
  Total latency: 50-200ms (consistent)

┌─────────────────────────────────────────────────┐
│                 Server/Workstation               │
│  ┌─────────────┐      ┌───────────────────────┐ │
│  │   Ollama    │◄────►│         n8n           │ │
│  │  (Port      │      │  ┌─────────────────┐  │ │
│  │   11434)    │      │  │  AI Agent       │  │ │
│  └─────────────┘      │  │  Workflows      │  │ │
│                       │  └─────────────────┘  │ │
│                       │  ┌─────────────────┐  │ │
│                       │  │  Business       │  │ │
│                       │  │  Logic          │  │ │
│                       │  └─────────────────┘  │ │
│                       └───────────────────────┘ │
└─────────────────────────────────────────────────┘

# docker-compose.yml
version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    restart: always
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=secure_password
      - N8N_HOST=localhost
      - N8N_PORT=5678
      - OLLAMA_HOST=http://ollama:11434
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - ollama
    restart: always

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - openwebui_data:/app/backend/data
    depends_on:
      - ollama
    restart: always

volumes:
  ollama_data:
  n8n_data:
  openwebui_data:

┌──────────────────────────────────────────────────────────┐
│                    Load Balancer                        │
└────────────────────┬─────────────────────────────────────┘
                     │
        ┌────────────┴────────────┐
        │                         │
┌───────▼───────┐       ┌────────▼────────┐
│   n8n Node 1  │       │   n8n Node 2    │
└───────┬───────┘       └────────┬────────┘
        │                        │
        └────────────┬───────────┘
                     │
              ┌──────▼──────┐
              │   Redis     │
              │  (Queue)    │
              └──────┬──────┘
                     │
        ┌────────────┼────────────┐
        │            │            │
┌───────▼─────┐ ┌────▼────┐ ┌─────▼──────┐
│ Ollama GPU  │ │ Ollama  │ │ Ollama CPU │
│ Server 1    │ │ GPU S2  │ │ Fallback   │
└─────────────┘ └─────────┘ └────────────┘

# Download and install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Start Ollama service
sudo systemctl start ollama
sudo systemctl enable ollama

# Verify installation
ollama --version
# Expected: ollama version 0.6.x

# Using Homebrew
brew install ollama

# Or download from https://ollama.com/download

# Start Ollama
ollama serve

# With GPU support (NVIDIA)
docker run -d \
  --gpus=all \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

# CPU only
docker run -d \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

# Essential models for business automation
ollama pull llama3.3:latest        # General purpose
ollama pull mistral:latest           # Reasoning tasks
ollama pull nomic-embed-text:latest  # Embeddings/RAG
ollama pull deepseek-r1:14b          # Complex analysis

# List downloaded models
ollama list

# Verify model works
ollama run llama3.3
>>> Hello, can you summarize what you can do?

# Create directories
mkdir -p ~/.n8n

# Run n8n container
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_secure_password \
  n8nio/n8n

# Access at http://localhost:5678

version: '3.8'

services:
  n8n:
    image: n8nio/n8n:latest
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=${N8N_USER:-admin}
      - N8N_BASIC_AUTH_PASSWORD=${N8N_PASSWORD:-changeme}
      - GENERIC_TIMEZONE=${TZ:-UTC}
      - OLLAMA_HOST=http://host.docker.internal:11434
    volumes:
      - ./n8n-data:/home/node/.n8n
    extra_hosts:
      - "host.docker.internal:host-gateway"

# Start services
docker-compose up -d

# View logs
docker-compose logs -f n8n

[Trigger: Manual] 
      ↓
[HTTP Request: Chat Completion]
      ↓
[Code: Parse Response]
      ↓
[No Operation: Display Result]

{
  "model": "llama3.3:latest",
  "prompt": "Say hello and confirm you're running locally",
  "stream": false
}

{
  "model": "llama3.3:latest",
  "response": "Hello! I'm running locally on your machine through Ollama...",
  "done": true
}

[Email Trigger: IMAP]
      ↓
[Function: Preprocess Email]
      ↓
[LLM Node: Classify Intent]
      ↓
[Switch: Route by Intent]
      ├── Support Request → [LLM: Draft Response] → [Send Email]
      ├── Sales Inquiry → [CRM: Create Lead] → [Notify Sales]
      ├── Complaint → [Slack: Alert Team] → [Human Review]
      └── Other → [Notion: Log for Review]

const email = $input.first().json;

// Clean and structure email data
const processed = {
  subject: email.subject,
  from: email.from,
  body: email.text || email.body,
  timestamp: email.date,
  attachments: email.attachments?.length || 0
};

// Truncate if too long for LLM context
if (processed.body.length > 4000) {
  processed.body = processed.body.substring(0, 4000) + "...";
}

return [{ json: processed }];

{
  "model": "mistral:latest",
  "prompt": "Classify this email into one category: SUPPORT_REQUEST, SALES_INQUIRY, COMPLAINT, or OTHER.

Email Subject: {{$json.subject}}
Email Body: {{$json.body}}

Respond with ONLY the category name.",
  "stream": false
}

{
  "model": "llama3.3:latest",
  "prompt": "Draft a helpful response to this customer support email. Be professional, empathetic, and provide actionable next steps.

Original Email:
Subject: {{$json.subject}}
Body: {{$json.body}}

Draft a response:",
  "stream": false
}

[Trigger: File Upload (Nextcloud/Drive)]
      ↓
[Function: Extract Text (PDF/DOCX)]
      ↓
[LLM: Generate Summary]
      ↓
[LLM: Extract Key Points]
      ↓
[Vector Store: Store Embeddings]
      ↓
[Notion/Airtable: Save Summary]
      ↓
[Slack: Notify Team]

// Using pdf-parse or mammoth libraries
const pdfParse = require('pdf-parse');
const mammoth = require('mammoth');

async function extractText(fileUrl, fileType) {
  const response = await fetch(fileUrl);
  const buffer = await response.buffer();
  
  if (fileType === 'pdf') {
    const data = await pdfParse(buffer);
    return data.text;
  } else if (fileType === 'docx') {
    const result = await mammoth.extractRawText({ buffer });
    return result.value;
  }
  
  return buffer.toString();
}

return extractText($input.first().json.url, $input.first().json.type);

{
  "model": "deepseek-r1:14b",
  "prompt": "Provide a comprehensive summary of this document in 3-4 paragraphs. Include: main topic, key arguments, conclusions, and any action items.

Document:
{{$json.text}}

Summary:",
  "stream": false
}

{
  "model": "nomic-embed-text:latest",
  "prompt": "{{$json.text}}",
  "stream": false
}

[Trigger: Scheduled / Manual]
      ↓
[Agent 1: Research Lead]
      ↓
[Parallel Execution]
      ├── [Agent 2: Data Collector]
      ├── [Agent 3: Analyst]
      └── [Agent 4: Writer]
      ↓
[Agent 5: Editor]
      ↓
[Format Output]
      ↓
[Deliver Report]

// Collects data from multiple sources
const sources = [
  { name: 'News', url: 'https://newsapi.org/v2/everything' },
  { name: 'Financial', url: 'https://api.marketdata.com' },
  { name: 'Social', url: 'https://api.socialmedia.com/trends' }
];

const results = await Promise.all(
  sources.map(async (source) => {
    const response = await fetch(source.url, {
      headers: { 'Authorization': `Bearer ${source.apiKey}` }
    });
    return { source: source.name, data: await response.json() };
  })
);

return [{ json: { collectedData: results } }];

{
  "model": "deepseek-r1:14b",
  "prompt": "You are a market analyst. Analyze the following data and identify key trends, opportunities, and threats.

Data:
{{$json.collectedData}}

Provide:
1. Executive Summary (2-3 sentences)
2. Key Trends (bullet points)
3. Opportunities
4. Threats/Risks
5. Recommendations",
  "stream": false
}

// Main workflow coordinates sub-workflows
const researchTopic = $input.first().json.topic;

// Execute data collection
const dataResult = await $executeWorkflow('Data Collector', { topic: researchTopic });

// Parallel analysis
const [analysis, competitive] = await Promise.all([
  $executeWorkflow('Analyst Agent', dataResult),
  $executeWorkflow('Competitive Agent', dataResult)
]);

// Final synthesis
const report = await $executeWorkflow('Writer Agent', {
  analysis: analysis.json,
  competitive: competitive.json
});

return [report];

# Add to docker-compose.yml
services:
  qdrant:
    image: qdrant/qdrant:latest
    ports:
      - "6333:6333"
    volumes:
      - qdrant_data:/qdrant/storage

[Trigger: New document]
      ↓
[Extract Text]
      ↓
[Chunk Text (Code)]
      ↓
[Generate Embeddings (Ollama)]
      ↓
[Store in Qdrant]

function chunkText(text, chunkSize = 500, overlap = 50) {
  const chunks = [];
  let start = 0;
  
  while (start < text.length) {
    const end = Math.min(start + chunkSize, text.length);
    chunks.push(text.substring(start, end));
    start = end - overlap;
  }
  
  return chunks.map((content, index) => ({
    content,
    metadata: { chunkIndex: index, totalChunks: chunks.length }
  }));
}

const text = $input.first().json.content;
return chunkText(text).map(chunk => ({ json: chunk }));

// 1. Convert query to embedding
const queryEmbedding = await $httpRequest({
  method: 'POST',
  url: 'http://localhost:11434/api/embeddings',
  body: {
    model: 'nomic-embed-text:latest',
    prompt: $input.first().json.query
  }
});

// 2. Search Qdrant
const searchResults = await $httpRequest({
  method: 'POST',
  url: 'http://localhost:6333/collections/documents/points/search',
  body: {
    vector: queryEmbedding.embedding,
    limit: 5,
    with_payload: true
  }
});

// 3. Generate response with context
const context = searchResults.result.map(r => r.payload.content).join('\n---\n');

return [{ json: { context, query: $input.first().json.query } }];

{
  "model": "llama3.3:latest",
  "prompt": "Answer the question based on the following context. If you cannot find the answer in the context, say so.

Context:
{{$json.context}}

Question: {{$json.query}}

Answer:",
  "stream": false
}

// n8n Code Node for HubSpot API
const hubspot = require('@hubspot/api-client');

const hubspotClient = new hubspot.Client({
  accessToken: $env.HUBSPOT_ACCESS_TOKEN
});

// Create contact with AI-enriched data
const contact = await hubspotClient.crm.contacts.basicApi.create({
  properties: {
    email: $input.first().json.email,
    firstname: $input.first().json.firstName,
    lastname: $input.first().json.lastName,
    company: $input.first().json.company,
    // Custom field with AI-generated lead score
    ai_lead_score: $input.first().json.leadScore,
    // AI-detected industry
    ai_industry: $input.first().json.industry
  }
});

return [{ json: contact }];

// Store AI-generated insights
const { Pool } = require('pg');

const pool = new Pool({
  connectionString: $env.DATABASE_URL
});

const result = await pool.query(
  `INSERT INTO ai_insights 
   (source_id, insight_type, content, confidence, created_at)
   VALUES ($1, $2, $3, $4, NOW())
   RETURNING *`,
  [
    $input.first().json.sourceId,
    $input.first().json.type,
    $input.first().json.content,
    $input.first().json.confidence
  ]
);

return [{ json: result.rows[0] }];

const task = $input.first().json.taskType;

const modelMap = {
  'quick_response': 'llama3.3:latest',
  'deep_analysis': 'deepseek-r1:14b',
  'code_review': 'qwen2.5-coder:latest',
  'document_summary': 'kimi-k2.5:32b'
};

return [{
  json: {
    model: modelMap[task] || 'llama3.3:latest',
    task: task
  }
}];

// Simple in-memory cache (for development)
const cache = new Map();

const cacheKey = JSON.stringify({
  prompt: $input.first().json.prompt,
  model: $input.first().json.model
});

if (cache.has(cacheKey)) {
  return [{ json: cache.get(cacheKey) }];
}

// Otherwise, make LLM call and cache result
const response = await $httpRequest({
  method: 'POST',
  url: 'http://localhost:11434/api/generate',
  body: {
    model: $input.first().json.model,
    prompt: $input.first().json.prompt,
    stream: false
  }
});

cache.set(cacheKey, response);
return [{ json: response }];

const redis = require('redis');
const client = redis.createClient({ url: $env.REDIS_URL });
await client.connect();

const cacheKey = `llm:${hash($input.first().json.prompt)}`;
const cached = await client.get(cacheKey);

if (cached) {
  return [{ json: JSON.parse(cached) }];
}

// Fetch from LLM, then cache
const response = await callLLM($input.first().json);
await client.setEx(cacheKey, 3600, JSON.stringify(response)); // 1 hour TTL

return [{ json: response }];

const items = $input.all();

// Process up to 5 items concurrently
const batchSize = 5;
const results = [];

for (let i = 0; i < items.length; i += batchSize) {
  const batch = items.slice(i, i + batchSize);
  const batchPromises = batch.map(item => 
    $httpRequest({
      method: 'POST',
      url: 'http://localhost:11434/api/generate',
      body: {
        model: 'llama3.3:latest',
        prompt: item.json.prompt,
        stream: false
      }
    })
  );
  
  const batchResults = await Promise.all(batchPromises);
  results.push(...batchResults);
}

return results.map((r, i) => ({ 
  json: { 
    input: items[i].json,
    response: r.response 
  }
}));

# Only allow local access to Ollama
sudo ufw allow from 127.0.0.1 to any port 11434
sudo ufw deny from any to any port 11434

# Allow n8n from specific IPs
sudo ufw allow from 192.168.1.0/24 to any port 5678

server {
    listen 443 ssl;
    server_name n8n.yourdomain.com;

    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;

    location / {
        proxy_pass http://localhost:5678;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

# Block external Ollama access
server {
    listen 80;
    server_name ollama.yourdomain.com;
    return 444;  # Close connection without response
}

// Store keys in environment variables, never in workflows
const apiKey = $env.SERVICE_API_KEY;

// For sensitive operations, add approval steps
if ($input.first().json.operation === 'delete') {
  // Require additional approval
  await sendApprovalRequest($input.first().json);
}

const sanitizeInput = (input) => {
  // Remove potentially harmful characters
  return input
    .replace(/[<>]/g, '')
    .replace(/javascript:/gi, '')
    .substring(0, 10000); // Limit length
};

const userInput = sanitizeInput($input.first().json.message);

const sensitivePatterns = [
  /\b\d{3}-\d{2}-\d{4}\b/g,  // SSN
  /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g,  // Credit card
  /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g  // Email (optional)
];

const filterSensitive = (text) => {
  let filtered = text;
  sensitivePatterns.forEach(pattern => {
    filtered = filtered.replace(pattern, '[REDACTED]');
  });
  return filtered;
};

return [{ json: { filtered: filterSensitive($input.first().json.llmResponse) } }];

const logEntry = {
  timestamp: new Date().toISOString(),
  workflow: $workflow.name,
  execution: $execution.id,
  node: 'AI_Classification',
  level: 'info',
  input: $input.first().json,
  output: response,
  duration: Date.now() - startTime,
  model: 'llama3.3:latest'
};

// Send to centralized logging
await $httpRequest({
  method: 'POST',
  url: $env.LOGGING_ENDPOINT,
  body: logEntry
});

#!/bin/bash
# health-check-ollama.sh

response=$(curl -s http://localhost:11434/api/tags)
if [ $? -eq 0 ] && [ ! -z "$response" ]; then
  echo "Ollama is healthy"
  exit 0
else
  echo "Ollama is down"
  # Restart service
  docker restart ollama
  exit 1
fi

#!/bin/bash
# health-check-n8n.sh

response=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:5678/healthz)
if [ "$response" -eq 200 ]; then
  echo "n8n is healthy"
  exit 0
else
  echo "n8n is down"
  docker restart n8n
  exit 1
fi

# Add to crontab
*/5 * * * * /path/to/health-check-ollama.sh
*/5 * * * * /path/to/health-check-n8n.sh

// Check for model updates weekly
const modelsToUpdate = ['llama3.3', 'mistral', 'deepseek-r1'];

for (const model of modelsToUpdate) {
  // Pull latest version
  await $httpRequest({
    method: 'POST',
    url: 'http://localhost:11434/api/pull',
    body: { name: `${model}:latest` }
  });
  
  // Log update
  console.log(`Updated ${model} to latest version`);
}

# Add to startup script
ollama run llama3.3:latest &
ollama run nomic-embed-text:latest &

# Set environment variable
export OLLAMA_KEEP_ALIVE=24h

docker exec n8n curl http://ollama:11434/api/tags

# Ensure containers are on same network
services:
  n8n:
    networks:
      - ai-network
  ollama:
    networks:
      - ai-network

networks:
  ai-network:
    driver: bridge

ollama pull llama3.3:8b
# vs llama3.3:70b

{
  "options": {
    "num_ctx": 4096  // Instead of default 8192
  }
}

sudo fallocate -l 16G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

services:
  ollama:
    deploy:
      resources:
        limits:
          memory: 32G

{
  "options": {
    "temperature": 0.0
  }
}

{
  "options": {
    "seed": 42
  }
}

let attempts = 0;
const maxAttempts = 3;

while (attempts < maxAttempts) {
  try {
    const response = await callLLM();
    if (validateResponse(response)) {
      return response;
    }
  } catch (e) {
    attempts++;
    await sleep(1000 * attempts); // Exponential backoff
  }
}

services:
  ollama:
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

// Quick tasks
const quickModel = 'llama3.3:8b';
// Deep reasoning
const reasoningModel = 'deepseek-r1:14b';

// Instead of 10 sequential requests
const batchResults = await Promise.all(
  items.map(i => processItem(i))
);