Discord-Bot mit Ollama

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Discord-Bot mit Ollama behandelt

• Wie Du einen Discord-Bot mit Ollama als KI-Backend baust.
• Wie Slash-Commands, Chat-Antworten und RAG funktionieren.
• Wie Du den Bot in Discord einrichtest und deployest.
• Praxisbeispiele für FAQ-Bot, Moderation und Community-Support.
• Best Practices für Rate-Limiting, Sicherheit und Moderation.

Einleitung: Discord-Bot mit Ollama verständlich erklärt

Ein Discord-Bot mit Ollama beantwortet Fragen in Deinem Discord-Server, mit lokalem KI-Modell, ohne dass Chat-Inhalte an OpenAI oder andere Cloud-Dienste gehen. Der Bot kann FAQ beantworten, Dokumente durchsuchen (RAG), moderieren und Workflows auslösen.

Dieser Artikel richtet sich an Anwender, die einen Discord-Bot mit lokaler KI bauen wollen. Grundlagen findest Du in Ollama und Discord-Bot Grundlagen.

Warum brauche ich einen Discord-Bot mit Ollama?

Stell Dir vor, Deine Community hat wiederkehrende Fragen: „Wie installiere ich X?”, „Wo finde ich Y?”, „Was ist Z?”. Ein Bot mit Ollama beantwortet diese Fragen automatisch, mit Deinem eigenen Wissen (RAG) und lokal, ohne API-Kosten.

Discord-Bot mit Ollama kurz erklärt

Du erstellst einen Discord-Bot (discord.py oder discord.js), der bei Nachrichten Ollama aufruft und die Antwort postet. Mit RAG kann der Bot Deine Dokumente durchsuchen. Mit Slash-Commands können Nutzer gezielt Funktionen aufrufen.

Der Kerngedanke lautet: Discord als Frontend, Ollama als Gehirn.

Für wen ist dieser Artikel gedacht?

• Community-Admins, die einen KI-Bot wollen.
• Entwicklerinnen und Entwickler, die Discord-Bots bauen.
• Self-Hoster, die KI-Bots lokal betreiben.
• Teams, die internen Support automatisieren.

Vorkenntnisse in Python/JavaScript und Ollama sind hilfreich.

Wichtige Begriffe

• Discord Bot - Programm in Discord. Wann nützlich: das Interface.
• Ollama - Lokaler Modellserver. Wann nützlich: das KI-Backend.
• Slash Commands - Befehle wie /ask. Wann nützlich: für strukturierte Aufrufe.
• RAG - Wissensdatenbank. Wann nützlich: für FAQ.
• discord.py / discord.js - Bot-Bibliotheken. Wann nützlich: für die Implementierung.
• Intent - Discord-Berechtigung. Wann nützlich: für Nachrichtenzugriff.
• Discord Bot Grundlagen - Bot-Basics. Wann nützlich: für Setup.

Setup: Discord-Bot erstellen

1. Discord Developer Portal

1. Gehe zu https://discord.com/developers/applications
2. „New Application” → Name eingeben
3. Tab „Bot” → „Add Bot”
4. Token kopieren (nie teilen!)
5. Tab „OAuth2” → „URL Generator”
   • Scope: bot, applications.commands
   • Permissions: Send Messages, Read Messages, Use Slash Commands
6. Generierte URL öffnen → Bot auf Server einladen

2. Bot mit discord.py

# bot.py
import discord
from discord import app_commands
import requests
import os

OLLAMA_URL = os.environ.get("OLLAMA_URL", "http://ollama:11434")
TOKEN = os.environ.get("DISCORD_TOKEN")

intents = discord.Intents.default()
intents.message_content = True
client = discord.Client(intents=intents)
tree = app_commands.CommandTree(client)

def call_ollama(prompt, system=None):
    """Ollama aufrufen"""
    messages = []
    if system:
        messages.append({"role": "system", "content": system})
    messages.append({"role": "user", "content": prompt})

    response = requests.post(
        f"{OLLAMA_URL}/api/chat",
        json={
            "model": "llama3.1",
            "messages": messages,
            "stream": False
        },
        timeout=60
    )
    return response.json()["message"]["content"]

@client.event
async def on_ready():
    await tree.sync()
    print(f"Bot online: {client.user}")

# Slash Command: /ask
@tree.command(name="ask", description="Stelle eine Frage an den KI-Bot")
async def ask(interaction: discord.Interaction, frage: str):
    await interaction.response.defer()  # KI braucht Zeit

    antwort = call_ollama(
        frage,
        system="Du bist ein hilfreicher Assistent auf einem Discord-Server. Antworte kurz und hilfreich."
    )

    await interaction.followup.send(f"**Frage:** {frage}\n\n{antwort}")

# Nachrichten beantworten (optional)
@client.event
async def on_message(message):
    if message.author.bot:
        return

    # Nur auf Erwähnungen reagieren
    if client.user.mentioned_in(message):
        async with message.channel.typing():
            antwort = call_ollama(
                message.content.replace(f"<@{client.user.id}>", ""),
                system="Du bist ein hilfreicher Assistent auf Discord."
            )
            await message.reply(antwort)

client.run(TOKEN)

3. Bot starten

pip install discord.py requests

export DISCORD_TOKEN="dein-bot-token"
export OLLAMA_URL="http://localhost:11434"

python bot.py

Praxisbeispiel 1: FAQ-Bot mit RAG

import chromadb

class FAQBot:
    def __init__(self):
        self.chroma = chromadb.HttpClient(host="chromadb", port=8000)
        self.collection = self.chroma.get_collection("faq")

    async def answer(self, question):
        """Frage mit RAG beantworten"""
        # Ähnliche Dokumente suchen
        results = self.collection.query(
            query_texts=[question],
            n_results=3
        )

        context = "\n".join(results["documents"][0])

        # Antwort generieren
        response = call_ollama(
            f"Kontext:\n{context}\n\nFrage: {question}",
            system="Beantworte die Frage basierend auf dem Kontext. Gib Quellen an."
        )

        return {
            "answer": response,
            "sources": results["metadatas"][0]
        }

# Slash Command
@tree.command(name="faq", description="Frage an die FAQ")
async def faq(interaction: discord.Interaction, frage: str):
    await interaction.response.defer()
    result = await faq_bot.answer(frage)

    embed = discord.Embed(
        title="FAQ-Antwort",
        description=result["answer"],
        color=discord.Color.blue()
    )
    embed.set_footer(text=f"Quellen: {', '.join(s['source'] for s in result['sources'])}")
    await interaction.followup.send(embed=embed)

Praxisbeispiel 2: Moderation-Bot

@client.event
async def on_message(message):
    if message.author.bot:
        return

    # KI prüft Nachricht
    analysis = call_ollama(
        f"Analysiere diese Nachricht:\n{message.content}\n\n"
        "Kategorien: normal, spam, toxisch, nsfw, offtopic\n"
        "Antworte: KATEGORIE|BEGRÜNDUNG",
        system="Du bist ein Moderations-Assistent."
    )

    category, reason = analysis.split("|", 1)

    if category in ["spam", "toxisch", "nsfw"]:
        await message.delete()
        await message.channel.send(
            f"⚠️ Nachricht von {message.author.mention} entfernt: {reason}"
        )
        # Log
        log_moderation(message, category, reason)

Praxisbeispiel 3: Dokumenten-Upload → Indexierung

@tree.command(name="index", description="Dokument für FAQ indexieren")
async def index(interaction: discord.Interaction, anhang: discord.Attachment):
    await interaction.response.defer()

    # Datei herunterladen
    content = await anhang.read()

    # Text extrahieren
    if anhang.filename.endswith(".pdf"):
        text = extract_pdf(content)
    else:
        text = content.decode("utf-8")

    # Chunks erstellen
    chunks = split_into_chunks(text, 500)

    # Embeddings erstellen
    for i, chunk in enumerate(chunks):
        embedding = get_embedding(chunk)
        collection.add(
            ids=[f"{anhang.filename}_{i}"],
            documents=[chunk],
            embeddings=[embedding],
            metadatas=[{"source": anhang.filename}]
        )

    await interaction.followup.send(
        f"✅ {anhang.filename} indexiert ({len(chunks)} Chunks)"
    )

Praxisbeispiel 4: Workflow auslösen

@tree.command(name="workflow", description="Workflow auslösen")
async def workflow(interaction: discord.Interaction, name: str, parameter: str):
    await interaction.response.defer()

    # n8n Webhook aufrufen
    response = requests.post(
        f"http://n8n:5678/webhook/{name}",
        json={"parameter": parameter, "user": str(interaction.user)}
    )

    await interaction.followup.send(f"Workflow {name} gestartet: {response.text}")

Docker-Setup

version: "3.8"

services:
  discord-bot:
    build: .
    container_name: discord-bot
    restart: unless-stopped
    environment:
      - DISCORD_TOKEN=${DISCORD_TOKEN}
      - OLLAMA_URL=http://ollama:11434
    networks:
      - ai-network
    depends_on:
      - ollama

  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    networks:
      - ai-network

volumes:
  ollama_data:

networks:
  ai-network:
    driver: bridge

Sicherheitshinweise

• Bot-Token geheim: Niemals in Code oder Git committen. Nutze Umgebungsvariablen. Siehe Secrets.
• Berechtigungen minimal: Der Bot sollte nur lesen und schreiben, keine Admin-Rechte.
• Rate-Limiting: Discord hat Rate-Limits. Implementiere Throttling.
• Content-Filter: KI kann unangemessene Inhalte generieren. Filtere Ausgaben. Siehe Guardrails.
• Prompt Injection: Nutzer können Injections senden. Siehe Prompt Injection.
• Audit Logging: Protokolliere alle Bot-Aktionen. Siehe Audit Logging.

Typische Stolpersteine

• Token im Code: Nie den Token direkt im Code. Nutze Umgebungsvariablen.
• Keine Intents: Ohne message_content Intent kann der Bot keine Nachrichten lesen.
• Rate-Limits: Discord limitiert API-Aufrufe. Implementiere Retry-Logik.
• Zu lange Antworten: Discord hat 2000-Zeichen-Limit. Antworten kürzen oder aufteilen.
• Ollama zu langsam: Große Modelle brauchen Zeit. Nutze defer() für Slash-Commands.
• Kein Error-Handling: Wenn Ollama ausfällt, sollte der Bot nicht abstürzen.

Weiterführende Links

• Discord Bot Grundlagen - Bot-Basics.
• Ollama - Modellserver.
• Lokales RAG - Wissensdatenbank.
• Discord.py - Bot-Bibliothek.
• Prompt Injection - Sicherheit.
• Guardrails - Content-Filter.

Key Takeaways:

• Discord-Bot + Ollama: Lokaler KI-Bot für Deinen Server.
• discord.py oder discord.js für die Implementierung.
• Slash-Commands für strukturierte Aufrufe, on_message für Chat.
• RAG für FAQ und Dokumenten-Q&A.
• Sicherheit: Token geheim, Rate-Limiting, Content-Filter.

FAQ

Quellen und weiterführende Literatur

• Discord Developer Portal - Bot erstellen.
• discord.py - Python-Bibliothek.
• discord.js - JavaScript-Bibliothek.
• Ollama - Lokaler Modellserver.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert