Private AI Agents: Zero to Hero (2026 Complete Guide)

mkdir n8n-agent && cd n8n-agent
cat > compose.yaml << 'EOF'
services:
  n8n:
    image: docker.n8n.io/n8nio/n8n:stable
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_RUNNERS_ENABLED=true
      - N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS=true
      - GENERIC_TIMEZONE=America/New_York
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      - n8n_data:/home/node/.n8n
volumes:
  n8n_data:
EOF
docker compose up -d
# Open http://localhost:5678

from crewai import Agent, Task, Crew, LLM

llm = LLM(model="ollama/qwen3.5:9b", base_url="http://localhost:11434")

researcher = Agent(
    role="Privacy Technology Researcher",
    goal="Find accurate, up-to-date information on the given topic",
    backstory="Expert researcher specializing in privacy tech and open-source AI.",
    llm=llm, verbose=True
)

writer = Agent(
    role="Technical Writer",
    goal="Write clear, accurate technical content based on research",
    backstory="Writes detailed technical guides for privacy-conscious users.",
    llm=llm, verbose=True
)

research_task = Task(
    description="Research the current state of private AI agents in 2026.",
    expected_output="A detailed research brief with key findings and version numbers.",
    agent=researcher
)

write_task = Task(
    description="Using the research brief, write a 500-word introduction.",
    expected_output="A polished 500-word introduction with accurate technical details.",
    agent=writer,
    context=[research_task]
)

crew = Crew(agents=[researcher, writer], tasks=[research_task, write_task])
result = crew.kickoff()

from autogen import ConversableAgent

config = {
    "config_list": [{
        "model": "qwen3.5:9b",
        "api_type": "ollama",
        "client_host": "http://localhost:11434",
        "stream": False
    }],
    "temperature": 0.7
}

assistant = ConversableAgent(
    name="Assistant",
    system_message="You are a helpful AI assistant. Be concise and accurate.",
    llm_config=config, human_input_mode="NEVER"
)

critic = ConversableAgent(
    name="Critic",
    system_message="Point out flaws and missing information in responses.",
    llm_config=config, human_input_mode="NEVER"
)

result = assistant.initiate_chat(
    critic,
    message="Explain why local AI agents are better for privacy.",
    max_turns=3
)

from langgraph.prebuilt import create_react_agent
from langchain_ollama import ChatOllama
from langchain_core.tools import tool

llm = ChatOllama(model="qwen3.5:9b", base_url="http://localhost:11434")

@tool
def get_file_contents(path: str) -> str:
    """Read the contents of a local file. Input: absolute file path."""
    try:
        return open(path).read()
    except Exception as e:
        return f"Error: {e}"

@tool
def list_directory(path: str) -> str:
    """List files in a directory. Input: absolute directory path."""
    import os
    try:
        return "\n".join(os.listdir(path))
    except Exception as e:
        return f"Error: {e}"

agent = create_react_agent(llm, tools=[get_file_contents, list_directory])
result = agent.invoke({
    "messages": [{"role": "user",
                  "content": "List files in /tmp and read the first .txt file."}]
})
print(result["messages"][-1].content)

# Start Qdrant
docker run -d -p 6333:6333 -p 6334:6334 \
  -v "$(pwd)/qdrant_storage:/qdrant/storage:z" \
  qdrant/qdrant
# Dashboard: http://localhost:6333/dashboard

# Install Python dependencies
pip install qdrant-client sentence-transformers

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct
from sentence_transformers import SentenceTransformer
import uuid, glob

embedder = SentenceTransformer("nomic-ai/nomic-embed-text-v1.5", trust_remote_code=True)
client = QdrantClient(url="http://localhost:6333")

client.create_collection(
    collection_name="private_docs",
    vectors_config=VectorParams(size=768, distance=Distance.COSINE)
)

# Ingest all markdown files
points = []
for filepath in glob.glob("/docs/**/*.md", recursive=True):
    content = open(filepath).read()
    words = content.split()
    chunks = [" ".join(words[i:i+500]) for i in range(0, len(words), 500)]
    for chunk in chunks:
        points.append(PointStruct(
            id=str(uuid.uuid4()),
            vector=embedder.encode(chunk).tolist(),
            payload={"text": chunk, "source": filepath}
        ))
client.upsert(collection_name="private_docs", points=points)

# Search function (use as agent tool)
def rag_search(query: str) -> str:
    results = client.query_points(
        collection_name="private_docs",
        query=embedder.encode(query).tolist(),
        limit=5
    ).points
    return "\n\n---\n\n".join([r.payload["text"] for r in results])

# 1. Isolate agents in Docker with restricted capabilities
docker run --rm \
  --network=none \
  --read-only \
  --tmpfs /tmp \
  --cap-drop=ALL \
  --security-opt=no-new-privileges \
  my-agent-image

# 2. Store secrets in HashiCorp Vault (never hardcode)
docker run -d --name vault -p 8200:8200 \
  -e VAULT_DEV_ROOT_TOKEN_ID=myroot hashicorp/vault:latest
vault kv put secret/agent/tools serper_api_key=your_key_here

# 3. Use Tailscale for remote access (never expose ports directly)
curl -fsSL https://tailscale.com/install.sh | sh && sudo tailscale up

# Full compose.yaml — complete private agent stack
services:
  n8n:
    image: docker.n8n.io/n8nio/n8n:stable
    ports: ["5678:5678"]
    environment:
      - N8N_RUNNERS_ENABLED=true
      - N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS=true
    extra_hosts: ["host.docker.internal:host-gateway"]
    volumes: [n8n_data:/home/node/.n8n]

  qdrant:
    image: qdrant/qdrant:latest
    ports: ["6333:6333", "6334:6334"]
    volumes: [qdrant_storage:/qdrant/storage]

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports: ["3000:8080"]
    environment:
      - OLLAMA_BASE_URL=http://host.docker.internal:11434
    extra_hosts: ["host.docker.internal:host-gateway"]
    volumes: [open_webui:/app/backend/data]

volumes:
  n8n_data:
  qdrant_storage:
  open_webui: