Gratis AI Discord-bots i 2026

Hvis du søker etter “free AI Discord bot”, finner du dusinvis av alternativer. Noen er faktisk gratis. De fleste er det ikke, i hvert fall ikke slik du kanskje forventer. Dette innlegget går gjennom hva som faktisk finnes, hvilke kompromisser som gjelder, og hva “gratis” egentlig koster når AI-inferens er involvert.

Hvorfor “gratis AI” er komplisert

Å kjøre en LLM koster penger. Hver gang en bruker sender en melding og får et svar, betaler noen for beregningen. For et driftet API som OpenAI eller Anthropic betaler du per token. For en self-hosted modell betaler du i maskinvare, strøm og vedlikeholdstid. Det finnes ingen vei rundt dette: inferens har en marginalkostnad som ikke er null.

Når en tjeneste tilbyr en “gratis AI-bot”, er ett av følgende sant:

1. Du betaler inferenskostnaden direkte (for eksempel ved å oppgi din egen API-nøkkel).
2. Tjenesten absorberer kostnaden og tjener den inn gjennom betalte nivåer, annonser eller datainnsamling.
3. Du kjører inferens selv på egen maskinvare med en open-source modell.
4. Gratisnivået er begrenset til lavt volum som begrenser leverandørens eksponering mot beregningskostnader.

Å forstå hvilket av disse som gjelder for en gitt bot, er nøkkelen til å vurdere om den faktisk passer for bruksområdet ditt.

De tre kategoriene gratis AI Discord-bots

1. Self-hosted open-source bots (faktisk gratis, du stiller med maskinvare)

Dette er det eneste alternativet der ingen tredjepart kontrollerer bruksgrensene dine. Du kjører en open-source LLM lokalt (eller på en VPS), kobler den til Discord via en bot du skriver eller forker, og håndterer alt selv.

Typisk stack:

• Ollama for lokal modellservering
• discord.py eller discord.js for Discord-boten
• En modell som Llama 3.1 8B, Mistral 7B eller Gemma 2 9B

Dette får du:

• Ingen kostnad per melding utover strøm
• Full kontroll over modellen, systemprompten og dataene
• Ingen rategrenser pålagt av en tredjepart (bare Discords egne API-grenser gjelder)
• Lokal modellbehandling: inferens blir på maskinen din, mens Discord fortsatt transporterer og lagrer meldingene

Dette gir du avkall på:

• Du trenger maskinvare. Å kjøre en modell med 7B parametere i rimelig hastighet krever en GPU med minst 8 GB VRAM, eller en moderne Mac med unified memory. CPU-inferens fungerer, men er tregt (flere sekunder per svar for en 7B-modell).
• Du vedlikeholder infrastrukturen. Oppdateringer, omstarter, overvåking og diskplass til modellvekter er ditt ansvar.
• Modellkvaliteten er lavere enn frontier-modeller. Llama 3.1 8B er kapabel, men den er ikke GPT-4o eller Claude Sonnet. For enkel Q&A og uformell samtale fungerer den fint. For nyansert resonnering eller kompleks dialog over flere runder kommer den til kort.
• Ingen innebygd kunnskapsbase, analyse eller handoff-funksjoner. Du bygger det du trenger.

Minimumskrav til maskinvare for vanlige modeller:

(Hastighetene er omtrentlige, målt på en RTX 4090. Kvantiserte varianter bruker mindre minne med en liten kvalitetskostnad.)

2. Freemium-administrerte tjenester (gratisnivå med grenser)

Dette er produkter der noen andre drifter AI-en og bot-infrastrukturen. Du konfigurerer boten gjennom et web-dashboard. Gratisnivået gir deg begrenset bruk, du betaler for mer.

Eksempler:

Quickchat AIs Free plan lar deg teste uten kredittkort. Discord-integrasjonen er tilgjengelig på alle nivåer, så du kan koble til boten din og teste den med ekte brukere før du forplikter deg. Tilkobling er ett klikk: i External Apps, åpne Discord og klikk Add to your Discord server, velg deretter serveren den skal legges til på. Betalte planer starter med Starter til $9/md., eller $8/md. fakturert årlig.

Den viktigste fordelen med administrerte tjenester er at du får funksjoner utover ren LLM-inferens: kunnskapsbaser bygget fra dokumentene og nettstedet ditt, samtaleanalyse (sentimentanalyse, emnedeteksjon), distribusjon på flere kanaler (samme agent fungerer på nettstedet ditt, WhatsApp, Slack og Discord), og human handoff for saker AI-en ikke kan løse. Å bygge dette fra bunnen av oppå en self-hosted modell er et betydelig ingeniørprosjekt.

MEE6 er primært en bot for moderering og engasjement. AI-chatfunksjonene er låst bak premiumabonnementet ($11.99/md. per tidlig 2026). Gratisnivået dekker nivåsystem, grunnleggende modereringskommandoer og velkomstmeldinger, men ikke AI-drevne samtaler.

Botpress har et gratisnivå med 2,000 innkommende meldinger per måned på tvers av alle kanaler. Det tilbyr en visuell flytbygger og støtter tilpassede LLM-konfigurasjoner. Oppsettet er imidlertid mer komplekst enn Quickchat for en enkel Discord-bot, siden Botpress primært er utformet for strukturerte samtaleflyter heller enn åpen chat.

3. BYO API-nøkkel-bots (du betaler LLM-leverandøren)

En tredje kategori: open-source bots som kjører på en server, men kaller et kommersielt API (OpenAI, Anthropic, Google osv.) for inferens. Du oppgir API-nøkkelen din. Selve botkoden er gratis, men du betaler per token til modellleverandøren.

Eksempler på GitHub:

• GPT Discord Bot (OpenAIs offisielle eksempel)
• Ulike fellesskapsbots bygget med discord.py + OpenAI Python SDK

Kostnad per melding med kommersielle API-er (omtrentlig, per tidlig 2026):

*Forutsatt ~500 inndatatokens og ~200 utdatatokens per meldingsutveksling, uten samtalehistorikk. Når samtalehistorikk er inkludert, skalerer inndatakostnadene lineært med kontekstlengden.

Ved 1,000 meldinger per måned med GPT-4o mini vil du bruke omtrent $0.30. Ved 10,000 meldinger per måned, omtrent $3.00. Disse tallene ser små ut til du tar med samtalehistorikk: hvis hver melding inkluderer hele samtalekonteksten (for eksempel 10 tidligere runder), blåses antallet inndatatokens per melding opp fra ~500 til ~5,000, slik at inndatakostnadene øker 10x og totalkostnaden øker.

Kostnadssammenligning på tvers av tilnærminger

Tabellen nedenfor anslår månedlige kostnader ved ulike meldingsvolumer. “Self-hosted” antar en liten VPS eller eksisterende maskinvare. “BYO API Key” bruker GPT-4o mini-prising. “Managed” bruker Quickchat AIs prising som referanse.

Merknader om self-hosted-kolonnen: intervallet avhenger av om du bruker en VPS kun med CPU (billigere, men tregere svar) eller en GPU-instans. Hetzner tilbyr CPU VPS-instanser for rundt $5-10/md. som kan kjøre en kvantisert 7B-modell, men svartidene vil være 5-15 sekunder. GPU-skyinstanser (for eksempel fra Lambda, RunPod eller Vast.ai) starter på rundt $0.20-0.50/t for én GPU, som tilsvarer $150-360/md. hvis de kjører 24/7. For sporadisk bruk kan spot-instanser eller serverless GPU-leverandører redusere dette.

BYO API-nøkkel-kolonnen viser et intervall fordi kostnadene avhenger mye av om du inkluderer samtalehistorikk i hver forespørsel. Nedre grense er én enkelt runde (ingen historikk), øvre grense er flere runder med ~10 meldinger kontekst.

Kolonnen for administrerte tjenester gjenspeiler Quickchats prising per juni 2026. Disse planene inkluderer funksjoner som håndtering av kunnskapsbase, analyse og støtte for flere kanaler som ikke finnes i de to andre tilnærmingene uten ekstra ingeniørarbeid.

Et raskt self-hosted oppsett: Python + discord.py + Ollama

Nedenfor er et minimalt fungerende eksempel på en Discord-bot som bruker Ollama for lokal inferens. Dette krever at Ollama er installert og kjører, og at en modell er hentet (for eksempel ollama pull llama3.1:8b).

Forutsetninger

1. Python 3.10+
2. Ollama installert og kjørende (curl -fsSL https://ollama.com/install.sh | sh)
3. En modell hentet: ollama pull llama3.1:8b
4. Et Discord-bot-token (opprett et i Discord Developer Portal)
5. Boten lagt til på serveren din med tillatelsene Send Messages og Read Message History

Installer avhengigheter

pip install discord.py aiohttp

Botkode

import discord
import aiohttp
import json

DISCORD_TOKEN = "your-bot-token-here"
OLLAMA_URL = "http://localhost:11434/api/chat"
MODEL = "llama3.1:8b"
SYSTEM_PROMPT = "Du er en hjelpsom assistent på en Discord-server. Hold svarene konsise."

# Store conversation history per channel (in-memory, resets on restart)
conversations: dict[int, list[dict]] = {}
MAX_HISTORY = 10  # Keep last 10 messages per channel

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


async def query_ollama(channel_id: int, user_message: str) -> str:
    """Send a message to Ollama and return the response."""
    if channel_id not in conversations:
        conversations[channel_id] = []

    conversations[channel_id].append({"role": "user", "content": user_message})

    # Trim history to avoid unbounded memory growth
    if len(conversations[channel_id]) > MAX_HISTORY:
        conversations[channel_id] = conversations[channel_id][-MAX_HISTORY:]

    messages = [{"role": "system", "content": SYSTEM_PROMPT}] + conversations[channel_id]

    payload = {
        "model": MODEL,
        "messages": messages,
        "stream": False,
    }

    async with aiohttp.ClientSession() as session:
        async with session.post(OLLAMA_URL, json=payload) as resp:
            if resp.status != 200:
                return f"Ollama returned status {resp.status}"
            data = await resp.json()
            reply = data["message"]["content"]

    conversations[channel_id].append({"role": "assistant", "content": reply})
    return reply


@client.event
async def on_ready():
    print(f"Logged in as {client.user}")


@client.event
async def on_message(message: discord.Message):
    # Ignore own messages
    if message.author == client.user:
        return

    # Only respond when mentioned
    if client.user not in message.mentions:
        return

    # Strip the mention from the message
    content = message.content.replace(f"<@{client.user.id}>", "").strip()
    if not content:
        return

    async with message.channel.typing():
        reply = await query_ollama(message.channel.id, content)

    # Discord has a 2000-character limit per message
    if len(reply) > 2000:
        for i in range(0, len(reply), 2000):
            await message.reply(reply[i:i+2000])
    else:
        await message.reply(reply)


client.run(DISCORD_TOKEN)

Dette er omtrent 60 kodelinjer og gir deg en fungerende AI-bot som svarer når den blir nevnt. Den holder samtalehistorikk per kanal i minnet (går tapt ved omstart) og håndterer Discords meldingsgrense på 2,000 tegn.

Hva denne minimale boten mangler

Koden ovenfor fungerer for testing og små servere. For alt utover det vil du møte flere problemer som produksjonsbots må håndtere:

• Vedvarende samtalehistorikk. Ordboken i minnet går tapt når prosessen starter på nytt. En produksjonsbot ville lagret samtaler i Redis eller en database.
• Ratebegrensning. Discord tillater 5 meldinger per 5 sekunder per kanal. Hvis boten din er populær, trenger du kø.
• Samtidige forespørsler. Ollama behandler som standard én forespørsel om gangen. Flere brukere som sender meldinger samtidig, blir lagt i kø. Du kan kjøre flere Ollama-instanser bak en lastbalanserer, eller bruke Ollamas OLLAMA_NUM_PARALLEL-alternativ (tilgjengelig siden v0.1.33).
• Feilhåndtering og nye forsøk. Ollama kan krasje, gå tom for minne eller returnere feilformede svar. Boten bør håndtere alt dette på en kontrollert måte.
• Håndtering av kontekstvindu. Innstillingen MAX_HISTORY = 10 er naiv. En bedre tilnærming teller tokens og trimmer for å passe innenfor modellens kontekstvindu (8,192 tokens for Llama 3.1 8B som standard, konfigurerbart opptil 128K med kvalitetsforringelse ved lengre kontekster).
• Trådstøtte. På Discord skjer botsamtaler ofte i threads. Håndtering av trådoppretting og historikk per tråd krever ekstra logikk.
• Kunnskapsbase / RAG. Hvis du vil at boten skal svare på spørsmål om prosjektets dokumentasjon, trenger du et oppsett for retrieval-augmented generation: embed dokumentene dine, lagre embeddings i en vektordatabase, og hent relevante utdrag før du sender dem til LLM-en.

Tekniske fallgruver

Rategrenser i Discord API

Discord pålegger rategrenser på flere nivåer:

• Grenser per rute: Hvert API-endepunkt har sin egen rategrense, returnert i svarheadere (X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset).
• Global grense: 50 forespørsler per sekund på tvers av alle endepunkter.
• Meldingsgrense per kanal: 5 meldinger per 5 sekunder per kanal.
• Gateway-grenser: 120 gateway-hendelser per 60 sekunder.

discord.py-biblioteket håndterer det meste av dette automatisk ved å legge forespørsler i kø når du treffer en grense. Hvis boten din er på mange servere eller kanaler samtidig, kan du likevel treffe den globale grensen. Da må du se på sharding (å dele botens servertilkoblinger over flere gateway-tilkoblinger).

For bots som bruker MESSAGE_CONTENT intent (kreves for å lese meldingstekst), krever Discord at du verifiserer boten hvis den er på mer enn 100 servere. Dette innebærer å sende inn en beskrivelse av hva boten gjør og få godkjenning fra Discord.

Kompromisser i modellkvalitet

Gapet mellom små open-source modeller og kommersielle frontier-modeller er mindre enn det var for to år siden, men det finnes fortsatt. Her er en grov sammenligning for vanlige Discord-botoppgaver:

Hvis Discord-boten din er for et gamingfellesskap og hovedsakelig håndterer uformell chat og enkle oppslag, fungerer en lokal 8B-modell godt. Hvis den er for kundestøtte der nøyaktighet betyr noe, blir kvalitetsgapet et reelt problem. Å holde seg i karakter handler også mindre om modellen enn om oppsettet: hvordan bygge en rollespill-AI-chatbot som holder seg i karakter viser hvor langt en personaprompt og en kanonisk kunnskapsbase kan ta selv en standardmodell.

Håndtering av kontekstvindu

Dette er den mest undervurderte tekniske utfordringen i Discord-bots. Discord-samtaler har i sin natur flere runder: brukere sender mange korte meldinger, og boten må huske hva som ble sagt tidligere i samtalen.

Hver gang boten svarer, må den inkludere tidligere samtalehistorikk i prompten. Dette betyr:

• Antall inndatatokens vokser lineært med samtalelengden.
• For API-baserte bots vokser kostnaden også lineært.
• For lokale modeller vokser inferenstiden med kontekstlengden (kvadratisk i attention-beregning, selv om optimaliseringer som Flash Attention hjelper).
• På et tidspunkt overstiger samtalen modellens kontekstvindu, og du trenger en strategi: kutt fra begynnelsen, oppsummer eldre meldinger, eller start en ny samtale.

En praktisk tilnærming er å beholde et rullerende vindu av de siste N meldingene og, hvis samtalen har vært lang, legge til et kort sammendrag av tidligere kontekst foran. Dette krever et ekstra LLM-kall for å generere sammendraget, men holder kostnaden per melding avgrenset.

Personvernkonsekvenser

Dette varierer betydelig etter tilnærming:

• Self-hosted: AI-inferens blir på maskinvaren din, så du kontrollerer logger og lagring for modellbehandlingen. Discord transporterer og lagrer fortsatt meldinger, lokal inferens gjør ikke hele samtalen lokal.
• BYO API Key: Meldinger sendes til API-leverandøren (OpenAI, Anthropic osv.). Sjekk retningslinjene deres for datalagring. Per tidlig 2026 sier OpenAI at de som standard ikke trener på API-data, og Anthropic har en lignende policy. Meldinger passerer likevel gjennom serverne deres.
• Administrerte tjenester: Meldinger behandles av tjenesteleverandøren. Sjekk personvernerklæringen og databehandleravtalene deres. For virksomheter som håndterer brukerdata i EU, er GDPR-samsvar viktig her. Quickchat AI behandler for eksempel data i EU og tilbyr en DPA for bedriftskunder.

For en uformell Discord-server er personvern vanligvis ikke en hovedbekymring. For en virksomhet som bruker en Discord-bot til kundestøtte, er det verdt å forstå nøyaktig hvor samtaledata lagres og hvem som har tilgang til dem.

Self-hosted vs. administrert: totale eierkostnader

Sammenligningen av rene beregningskostnader i tabellen ovenfor forteller bare deler av historien. Totale eierkostnader inkluderer ingeniørtid.

Dette bygger du selv med en self-hosted bot:

• Botkode og utrulling
• Lagring av samtalehistorikk
• Håndtering av kontekstvindu
• Feilhåndtering og overvåking
• Kunnskapsbase / RAG-pipeline (hvis nødvendig)
• Analyse og logging
• Støtte for flere kanaler (hvis nødvendig)

Konservativt tar det 40-80 timer ingeniørtid for en erfaren utvikler å bygge en produksjonsklar self-hosted AI Discord-bot med samtalehistorikk, kunnskapsbase og grunnleggende analyse. Vedlikehold (modelloppdateringer, avhengighetsoppdateringer, feilsøking, overvåking) legger til løpende tid.

Dette får du rett ut av boksen med en administrert tjeneste:

• Bot-hosting og oppetidsstyring
• Kunnskapsbase bygget fra nettstedet, dokumentasjonen og filene dine
• Samtaleanalyse (sentiment, emner, vurderinger)
• Distribusjon på flere kanaler (samme agent på Discord, nettsted, WhatsApp, Slack osv.)
• Human handoff når AI-en ikke kan hjelpe
• AI Actions (tilpassede API-kall utløst av samtalekontekst), inkludert modereringshandlinger som timeout, kick og ban

Spørsmålet er om den månedlige kostnaden for den administrerte tjenesten er lavere enn alternativkostnaden for ingeniørtiden din. For en soloutvikler som driver en hobby-Discord-server, er self-hosting med Ollama sannsynligvis riktig valg. For en virksomhet som bruker Discord som en kundevendt supportkanal, taler regnestykket vanligvis for en administrert tjeneste fordi funksjonene rundt kjernen i LLM-en (analyse, kunnskapsbase, handoff) er det som gjør boten faktisk nyttig. Guiden for AI-ticket-bot bygger nøyaktig den kombinasjonen ende til ende på Free plan, slik at du kan prise alternativet opp mot noe konkret.

Sammendrag

Det finnes ingen universelt “beste” gratis AI Discord-bot. Riktig valg avhenger av hva “gratis” betyr for deg:

• Hvis du vil ha null løpende kostnad og har maskinvare tilgjengelig, bruk self-hosting med Ollama og en open-source modell. Du kontrollerer lokal modellbehandling og datalagringen for den, mens Discord fortsatt transporterer og lagrer meldinger. Du gir avkall på modellkvalitet sammenlignet med frontier-modeller, og du tar på deg alt ingeniørarbeidet.
• Hvis du vil teste med ekte brukere før du betaler noe, lar Quickchat AIs Free plan deg starte uten kredittkort. Discord-integrasjonen fungerer på Free plan, og betalte planer starter på $9/md.
• Hvis du vil ha frontier-modellkvalitet og er komfortabel med å håndtere API-nøkler, gir en BYO API-nøkkel-bot deg det med lave kostnader per melding (særlig med GPT-4o mini eller Gemini Flash). Du må fortsatt drifte botkoden og bygge alle funksjoner utover ren chat.
• Hvis du trenger produksjonsfunksjoner (kunnskapsbase, analyse, handoff, flere kanaler), er en administrert tjeneste den raskeste veien. Vurder basert på meldingsvolumet du forventer og funksjonene du faktisk trenger.

Ordet “gratis” i “gratis AI Discord-bot” gjør mye arbeid. Beregningen koster alltid noe. Spørsmålet er hvem som betaler for den, og hva du får (eller gir avkall på) til gjengjeld.

For en bredere sammenligning av alle AI Discord-bots (ikke bare gratis), se vår oversikt Beste AI Discord-bots i 2026. Hvis serveren din spesifikt er en supportkanal, går AI Discord Ticket Bot gjennom hvordan du svarer fra dokumentasjonen din og eskalerer resten til private ticket-tråder.