AI Setup for Beginners: Your Own AI System in 4 Steps

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

What This Article Covers

A clean AI starter project that gives you not just a working system in four steps, but teaches you how the pieces fit together:

1. Brandkit Text File: Everything the AI needs to know about you, your brand, or your company.
2. Second Brain: Obsidian as a knowledge base that grows from your brandkit.
3. LiteLLM: The gateway that shows you how models, APIs, and costs connect.
4. Hermes Agent: The active assistant that uses all three parts together.

At the end, you won’t have a toy demo, but an infrastructure you understand and can expand.

Why This Setup Teaches You Real AI

Most beginners start with “some chat app” and learn nothing about the layers underneath. This project shows you all four levels that every serious AI system has: Context (Brandkit), Knowledge (Second Brain), Model Access (LiteLLM), and Execution (Agent). Once you’ve wired these layers together yourself, you’ll understand every AI tool you encounter afterward.

Step 1: The Brandkit Text File

The brandkit is a single Markdown file that tells the AI who it’s working for. Later it becomes your system prompt, RAG source, and agent context all at once. Create brandkit.md:

# Brandkit: [Your Name / Company]

## Who I am / who we are
Freelancer for web development, since 2019, Bochum.
Solo operation, clients: local trades and practices.

## Tone & Style
Informal, direct, no filler. Technically precise but understandable to
non-technical people. No emojis in client-facing text.

## What I offer
- Websites with Astro (from 2,500 €)
- SEO basics & maintenance (150 €/month)
- Email: info@example.de

## What I don't do
No online shops, no app development, no discounts below 10%.

## Target audience
Business owners of small companies, 40-65 years old, minimal technical knowledge.

## Recurring phrases
"Fixed price, no surprises", "runs locally on your systems"

Why this is powerful: Every request to the AI gets this file as context. The AI then writes quote texts in your voice, knows your prices, says “no” to jobs you don’t do. One text file, zero tooling, the most important quality lever there is.

Rule: Update it as soon as something changes. It’s alive.

Step 2: The Second Brain with Obsidian

The brandkit is the beginning. Now add everything else the AI should know: projects, client notes, snippets, learnings, briefs. Obsidian is the standard here (free, local Markdown files, no cloud needed). Alternatively, any note system that creates real files works (Logseq, Joplin, a simple folder).

my-brain/
├── brandkit.md          ← from step 1
├── clients/
│   ├── carpenter-mueller.md
│   └── dentist-dr-weber.md
├── projects/
│   ├── website-relaunch.md
│   └── seo-checklist.md
├── snippets/
│   ├── quote-template.md
│   └── objection-handling.md
└── learnings/
    └── what-worked.md

The trick: Because everything is Markdown files, the AI can read the folder directly. Later this becomes a RAG knowledge database (see Document Bot for Companies and RAG Basics). For now it’s enough to reference files in your prompts.

Step 3: Install LiteLLM to Understand How Everything Connects

Now the infrastructure part. LiteLLM is a gateway: it presents a single OpenAI-compatible endpoint in front of all models, local ones (Ollama) and cloud ones (OpenAI, Anthropic, Google). One endpoint, all models, and you see exactly what a request is, what a token costs, how a model switch works.

# Install
pip install litellm[proxy]

# Or via Docker
docker run -p 4000:4000 ghcr.io/berriai/litellm:main-latest

litellm-config.yaml:

model_list:
  - model_name: local-qwen
    litellm_params:
      model: ollama/qwen3.8:27b
      api_base: http://localhost:11434
  - model_name: claude-sonnet
    litellm_params:
      model: anthropic/claude-sonnet-4-5
      api_key: os.environ/ANTHROPIC_API_KEY
  - model_name: gpt-5-mini
    litellm_params:
      model: openai/gpt-5-mini
      api_key: os.environ/OPENAI_API_KEY

general_settings:
  master_key: sk-your-key

litellm --config litellm-config.yaml --port 4000

# Test: same call, two models
curl http://localhost:4000/chat/completions \
  -H "Authorization: Bearer sk-your-key" \
  -d '{"model": "local-qwen", "messages": [{"role": "user", "content": "Hello"}]}'

What you learn here: The agent never calls “OpenAI” or “Ollama” directly, always localhost:4000 with a model name. Switch the model, change one string. Cost tracking, rate limits, and fallbacks (fallbacks: [{"local-qwen": ["claude-sonnet"]}]) come for free. This is exactly the architecture that companies run internally, just in miniature.

Step 4: Hermes as an Active Assistant Using Everything

Now the execution layer. Hermes Agent is a persistent AI assistant with memory that runs continuously and completes tasks. Wire it like this:

Hermes Agent
  ├── System prompt/context  → brandkit.md (Step 1)
  ├── Knowledge base         → my-brain/ (Step 2, readable/RAG)
  └── Model endpoint         → LiteLLM :4000 (Step 3)

In the Hermes config, set the LiteLLM endpoint as an OpenAI-compatible API:

llm:
  base_url: http://localhost:4000
  api_key: sk-your-key
  model: local-qwen
context_files:
  - /home/you/my-brain/brandkit.md
memory_dir: /home/you/my-brain/

This is where the real “understanding AI” happens: you ask Hermes “write a quote for the Mueller job”, he pulls the brandkit (tone, prices), reads clients/carpenter-mueller.md (context), sends it through LiteLLM to your local model, and you see in the LiteLLM log exactly the request, the tokens, the costs. Every layer is visible and replaceable.

What You Understand Now (and Where It Goes Next)

After this setup, you can answer what most AI users cannot:

• What a system prompt/context file is and why it decides everything (Brandkit)
• What a knowledge base/RAG source is (Second Brain)
• What an LLM gateway does and what an API call looks like (LiteLLM)
• What an agent is: a loop of context plus model plus tools (Hermes)

Logical next steps: wire the brain folder as a real RAG database, configure LiteLLM fallbacks and cost limits, connect Hermes to n8n automations (for example, “new email → agent drafts reply in brandkit voice”), or run a local model for the data protection angle.

Further Reading

• IRC-Coding.de: Programming tutorials.
• Hermes Agent: The agent in detail.
• Ollama: Local models behind LiteLLM.
• RAG Basics: From brain to knowledge database.
• Document Bot for Companies: The advanced project.
• n8n Workflows: Automate the agent.

Key Takeaways:

• The beginner setup has 4 layers: Brandkit (context) → Obsidian Second Brain (knowledge) → LiteLLM (model gateway) → Hermes (execution).
• The brandkit is a Markdown file with everything the AI needs to know about you/your company: tone, offerings, prices, boundaries.
• Obsidian creates local Markdown files that the AI can read directly, the foundation for later RAG.
• LiteLLM shows you the infrastructure: one OpenAI-compatible endpoint for local and cloud models, with logging and cost control.
• Hermes Agent connects everything: brandkit as system prompt, brain as memory, LiteLLM as the model source. This teaches you how every AI system works.

FAQ

Sources and Further Reading

• LiteLLM (GitHub), Obsidian
• Hermes Agent, Ollama
• IRC-Coding.de: Programming tutorials.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert