Legg til AI-funksjoner i appen din: en kodeorientert guide

Legg til AI-funksjoner i appen din: en kodeorientert guide

Sist oppdatert: 6. juni 2026.

De fleste guider om å "legge til AI i appen din" er skrevet av byråer som ønsker å selge deg et konsulentprosjekt på seks sifre. Denne gir deg den kodeorienterte tilnærmingen: fungerende OpenAI- og Anthropic-API-anrop, streaming-UI med Vercel AI SDK, kostnadsformler du kan putte inn i et regneark, og produksjonsmønstre som holder appen din stabil når LLM-en bestemmer seg for å oppføre seg rart. Du integrerer AI i din eksisterende app uten å skrive om noe som helst.

Hurtigoversikt — Hva du kan bygge (og hva det koster)

Før du velger hvilken AI-funksjon du skal lansere først, her er en realistisk gjennomgang. Disse estimatene er basert på 100 aktive brukere og gpt-4o-mini som standardmodell, med mindre funksjonen krever noe tyngre.

Velg funksjonen som er både enklest og mest verdifull for produktet ditt. For de fleste SaaS-apper er det enten en innebygd chatassistent eller innholdssammendrag. Begynn der, bevis at det fungerer, og bygg deretter videre.

Resten av denne guiden går gjennom hvert trinn — fra ditt første API-anrop til produksjonsklar distribusjon.

Før du skriver en linje kode — Når du IKKE bør legge til AI

Her er noe ingen andre forteller deg: ikke bruk en LLM hvis et regex, en SQL-spørring eller et enkelt if-uttrykk løser problemet. Hvert AI API-anrop koster penger, legger til latens og introduserer ikke-determinisme. Før du integrerer AI i din eksisterende app, kjør "regex-testen".

Regex-testen

Når AI faktisk tilfører verdi

Bruk en LLM når inndata er rotete, ustrukturert eller varierer kraftig — og når utdata må være naturlige, kontekstbevisste eller kreative. Hvis dataene dine er rene og reglene dine er tydelige, hopp over AI og spar budsjettet.

En rask kostnadsvirkelighet: selv gpt-4o-mini på $0,15 per million inndatatokens legger seg opp. Tusen brukere som gjør 10 forespørsler per dag på 500 tokens hver = 5 millioner tokens/måned = omtrent $0,75/måned i inndatakostnader. Billig, men ikke gratis. Og hvis du ved en feiltakelse ruter disse forespørslene til gpt-4o ($2,50/1M tokens), er det $12,50/måned — fortsatt håndterbart, men 16 ganger dyrere for oppgaver som ikke trenger den ekstra intelligensen.

Velge modell og leverandør

Det er tre store leverandører verdt å vurdere for de fleste SaaS LLM-integrasjonsprosjekter. Her er situasjonen tidlig i 2026.

Priser fra OpenAI, Anthropic og Google AI per juni 2026.

Begynn billig, oppgrader ved behov

Tilnærmingen som sparer penger: begynn med gpt-4o-mini eller claude-haiku-4.5 for alt. Kjør det en uke, mål kvaliteten med ekte brukertilbakemeldinger, og oppgrader bare til en større modell for de spesifikke oppgavene der den billige modellen ikke holder mål. De fleste sammendrag-, klassifiserings- og autofullføringsfunksjoner fungerer perfekt på mini-modeller.

For en dypere titt på å bygge hele AI-stakken din, sjekk ut vår AI SaaS Stack-guide.

Din første AI-funksjon — API-integrering

Tid for å skrive kode. Her er nøyaktig samme operasjon — et chat completion-anrop — i både Python og TypeScript. Velg det som backenden din bruker.

Python (OpenAI SDK)

# pip install openai
import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

def ask_ai(user_message: str) -> str:
    """Call the LLM and return the response text."""
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "You are a helpful assistant for our SaaS product."},
            {"role": "user", "content": user_message},
        ],
        temperature=0.7,
        max_tokens=1024,
    )
    return response.choices[0].message.content

TypeScript (OpenAI SDK)

// npm install openai
import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

async function askAI(userMessage: string): Promise<string> {
  const response = await client.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [
      { role: "system", content: "You are a helpful assistant for our SaaS product." },
      { role: "user", content: userMessage },
    ],
    temperature: 0.7,
    max_tokens: 1024,
  });
  return response.choices[0].message.content ?? "";
}

Hvor denne koden hører hjemme i appen din

Kall aldri OpenAI fra frontenden. Noensinne. Denne koden hører hjemme i:

• Next.js: en API-rute (app/api/chat/route.ts)
• FastAPI: et endepunkt (@app.post("/api/chat"))
• Express: en handler (router.post("/api/chat", ...))

Frontenden din sender en forespørsel til ditt backend, backenden din kaller OpenAI og returnerer resultatet. Dette holder OPENAI_API_KEY på serveren der den hører hjemme.

Det er alt. Du har en fungerende AI-funksjon. Men den føles treg — brukeren klikker "send" og stirrer på en tom skjerm i 2-3 sekunder. Streaming løser det.

Gjøre det levende — Strøm AI-svar

En ventetid på 2-3 sekunder uten tilbakemelding føles ødelagt. Streaming gjør det samme svaret umiddelbart ved å vise tokens når de ankommer — skrivemaskineffekten du har sett i ChatGPT. Enhver produksjons-AI-app bruker det, og det er overraskende enkelt å implementere.

Serverside streaming (Python + TypeScript)

Her er Python-metoden med FastAPI og Server-Sent Events:

# pip install fastapi openai sse-starlette
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from openai import OpenAI
import os

app = FastAPI()
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

@app.post("/api/chat")
async def chat(user_message: str):
    """Stream the LLM response token by token."""
    def generate():
        stream = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "You are a helpful SaaS assistant."},
                {"role": "user", "content": user_message},
            ],
            stream=True,
        )
        for chunk in stream:
            if chunk.choices[0].delta.content:
                yield chunk.choices[0].delta.content

    return StreamingResponse(generate(), media_type="text/event-stream")

Og TypeScript-motstykket med Next.js og Vercel AI SDK — som håndterer streaming-rørleggerarbeidet for deg:

// npm install ai openai
// app/api/chat/route.ts (Next.js App Router)
import { openai } from "@ai-sdk/openai";
import { streamText } from "ai";

export async function POST(req: Request) {
  const { messages } = await req.json();

  const result = streamText({
    model: openai("gpt-4o-mini"),
    system: "You are a helpful SaaS assistant.",
    messages,
  });

  return result.toDataStreamResponse();
}

Klientside: Vercel AI SDK-metoden

På React-siden håndterer useChat-hooken alt — meldingstilstand, streaming, feilhåndtering:

// components/Chat.tsx
"use client";
import { useChat } from "@ai-sdk/react";

export default function Chat() {
  const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({
    api: "/api/chat",
  });

  return (
    <div>
      {messages.map((m) => (
        <div key={m.id} className={m.role === "user" ? "user-msg" : "ai-msg"}>
          {m.content}
        </div>
      ))}
      <form onSubmit={handleSubmit}>
        <input value={input} onChange={handleInputChange} placeholder="Still et spørsmål..." />
        <button type="submit" disabled={isLoading}>Send</button>
      </form>
    </div>
  );
}

En fullt fungerende streaming AI-chat på omtrent 40 kodelinjer fordelt på server og klient. useChat-hooken håndterer meldingsarrayen, legger til strømmede tokens i sanntid og håndterer lastetilstand automatisk. Du rører ikke EventSource eller ReadableStream direkte. For mer om hvordan streaming fungerer under panseret er Vercel AI SDK-dokumentasjonen den definitive referansen.

Gjøre outputs pålitelige — Strukturerte outputs og function calling

Rå LLM-tekst er utmerket for chat. Det er forferdelig for alt koden din trenger å tolke. Hvis du ekstraherer data, utløser handlinger eller bygger strukturert UI trenger du strukturerte outputs.

Strukturerte outputs (JSON-modus)

OpenAIs response_format-parameter tvinger modellen til å returnere gyldig JSON som samsvarer med skjemaet ditt. Ikke mer håping om at modellen produserer tolkbar tekst:

from pydantic import BaseModel
from openai import OpenAI

client = OpenAI()

class ProductReview(BaseModel):
    sentiment: str  # "positive", "negative", "neutral"
    key_points: list[str]
    rating: int  # 1-5
    recommended: bool

response = client.beta.chat.completions.parse(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Extract a structured review from user text."},
        {"role": "user", "content": "Amazing product! Fast shipping, great quality. Only downside is the price."},
    ],
    response_format=ProductReview,
)

review = response.choices[0].message.parsed
print(review.sentiment)    # "positive"
print(review.rating)       # 4
print(review.key_points)   # ["Fast shipping", "Great quality", "High price"]

Modellen er begrenset til å returnere nøyaktig de feltene du definerer. Ingen tolkningsfeil, ingen regex-ekstraksjon, ingen "noen ganger returnerer den Markdown og noen ganger ikke". For den fullstendige referansen om skjemaer, moduser og kantsaker, se vår LLM Strukturerte Outputs-guide.

Function calling for apphandlinger

Function calling lar LLM-en utløse handlinger i applikasjonen din — oppdatere en databasepost, sende en e-post eller kalle et eksternt API. Du definerer tilgjengelige verktøy og modellen bestemmer når de skal brukes:

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "Update my email to [email protected]" }],
  tools: [
    {
      type: "function",
      function: {
        name: "update_user_profile",
        description: "Updates a field on the user's profile",
        parameters: {
          type: "object",
          properties: {
            field: { type: "string", enum: ["email", "name", "avatar_url"] },
            value: { type: "string" },
          },
          required: ["field", "value"],
        },
      },
    },
  ],
});

// The model returns a tool_call -- you execute it in your backend
const toolCall = response.choices[0].message.tool_calls?.[0];
if (toolCall?.function.name === "update_user_profile") {
  const args = JSON.parse(toolCall.function.arguments);
  await db.users.update({ [args.field]: args.value }); // Your DB call
}

Modellen kjører ingenting direkte. Den forteller deg hva du skal kalle og med hvilke argumenter, og du kjører den faktiske funksjonen i ditt sikre backend. Det er slik du bygger AI-funksjoner som går utover chat og faktisk gjør ting. Anthropic har et lignende tool use-API hvis du bruker Claude.

Legge til kunnskap — RAG på 50 linjer

LLM-en din vet ingenting om produktet ditt, dokumentasjonen din eller brukerne dine. RAG (Retrieval-Augmented Generation) løser det: søk i dataene dine først, og send deretter de relevante delene til modellen som kontekst. Det er det vanligste mønsteret for å gjøre AI-funksjoner bedriftsspesifikke.

Mønsteret: søk, deretter spør

1. Embed dokumentene dine til vektorer (én gang, ved innlasting)
2. Lagre vektorene i en database (pgvector, Pinecone, Qdrant, Weaviate)
3. Hent de mest relevante delene når en bruker stiller et spørsmål
4. Injiser disse delene i LLM-prompten som kontekst

Minimal RAG-implementering

# pip install openai numpy psycopg2-binary pgvector
from openai import OpenAI
import numpy as np

client = OpenAI()

# Step 1: Embed a document chunk
def embed(text: str) -> list[float]:
    response = client.embeddings.create(model="text-embedding-3-small", input=text)
    return response.data[0].embedding

# Step 2: Store in pgvector (assumes table with vector column exists)
def store_chunk(cursor, text: str, embedding: list[float]):
    cursor.execute(
        "INSERT INTO documents (content, embedding) VALUES (%s, %s)",
        (text, np.array(embedding).tolist()),
    )

# Step 3: Retrieve relevant chunks
def search(cursor, query: str, top_k: int = 3) -> list[str]:
    query_embedding = embed(query)
    cursor.execute(
        """SELECT content FROM documents
           ORDER BY embedding <=> %s::vector LIMIT %s""",
        (np.array(query_embedding).tolist(), top_k),
    )
    return [row[0] for row in cursor.fetchall()]

# Step 4: Ask the LLM with context
def ask_with_context(question: str, cursor) -> str:
    chunks = search(cursor, question)
    context = "\n\n".join(chunks)
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": f"Answer using this context:\n\n{context}"},
            {"role": "user", "content": question},
        ],
    )
    return response.choices[0].message.content

Det er hele RAG-pipelinen på omtrent 40 linjer. For en produksjonsklar konfigurasjon med chunking-strategier, hybridsøk og evaluering, se vår fullstendige guide til å bygge en RAG-applikasjon. Hvis du evaluerer rammeverk tilbyr LangChain og LlamaIndex begge abstraksjoner på høyere nivå.

Produksjonsmønstre — Kostnader, sikkerhet og feilhåndtering

Alt ovenfor fungerer utmerket i utvikling. Produksjon er der det blir interessant. Denne delen dekker problemene du støter på to uker etter at du har distribuert AI-funksjonen din — og hvordan du løser dem før de koster deg søvn (eller penger). Se også vår guide til LLM function calling.

Tokenbudsjettberegning (hva AI-funksjonen din faktisk koster)

Slutt å gjette. Her er formelen: brukere × forespørsler/dag × gen_tokens × kostnad_per_token = månedskostnad.

Vekstnivået er der folk blir overrasket. Med 5 000 brukere vil du ha modellruting: send enkle forespørsler (sammendrag, klassifisering) til gpt-4o-mini og rut bare komplekse forespørsler (flertrinnstenking, kodegenerering) til gpt-4o. Det kan redusere kostnadene med 60-70%.

Andre kostnadsoptimeringstaktikker:

• Prompt-caching: OpenAI og Anthropic tilbyr begge opptil 50-90% besparelser på gjentatte promptprefikser
• max_tokens-grenser: begrens utdatalengden slik at modellen ikke raver på
• Semantisk caching: hvis en bruker stiller det samme spørsmålet to ganger, returner det cachede svaret

For avanserte prompt-optimerings- og caching-strategier, se vår guide om context engineering-teknikker.

API-nøkkelsikkerhet (backend-proxy-mønsteret)

Det burde være selvfølgelig, men det fortsetter å dukke opp i produksjonsapper: eksponer aldri API-nøklene dine i frontendkode. Ikke i miljøvariabler som pakkes inn i klienten. Ikke i en "skjult" JavaScript-variabel. OWASP Top 10 for LLM-applikasjoner lister sensitiv informasjonseksponering (LLM02:2025) som en topprisiko.

Løsningen er enkel: frontenden din kaller ditt backend-API. Backenden din kaller OpenAI. API-nøkkelen lever utelukkende på serveren, lastet fra en miljøvariabel eller en hemmelighetsbehandler.

Implementer også hastighetsbegrensning per bruker for å forhindre at en enkelt bruker tømmer API-budsjettet ditt. Noe som fører oss til:

Hastighetsbegrensning per bruker

Spor bruk på brukernivå, ikke bare på globalt nivå. En gratisbruker som oppdager AI-endepunktet ditt og avfyrer 10 000 forespørsler gjør CFO-en din veldig ulykkelig.

Feilhåndtering og fallback-kjeder

LLM-API-er går ned. De returnerer tull. De treffer hastighetsbegrensninger. Appen din trenger å håndtere alt dette elegant. Her er et retry-med-fallback-mønster:

import OpenAI from "openai";
import Anthropic from "@anthropic-ai/sdk";

const openai = new OpenAI();
const anthropic = new Anthropic();

async function aiWithFallback(prompt: string): Promise<string> {
  const models = [
    () => callOpenAI("gpt-4o-mini", prompt),
    () => callOpenAI("gpt-4o", prompt),
    () => callAnthropic("claude-3-5-haiku-latest", prompt),
  ];

  for (const callModel of models) {
    try {
      return await withRetry(callModel, { maxRetries: 2, baseDelay: 1000 });
    } catch (err) {
      console.warn(`Model failed, trying next fallback...`, err);
    }
  }
  // All models failed -- return cached or static response
  return "Jeg kan midlertidig ikke behandle forespørselen din. Prøv igjen om litt.";
}

async function withRetry<T>(fn: () => Promise<T>, opts: { maxRetries: number; baseDelay: number }): Promise<T> {
  for (let i = 0; i <= opts.maxRetries; i++) {
    try {
      return await fn();
    } catch (err: any) {
      if (i === opts.maxRetries) throw err;
      if (err?.status === 429 || err?.status >= 500) {
        await new Promise((r) => setTimeout(r, opts.baseDelay * 2 ** i)); // Exponential backoff
      } else {
        throw err; // Don't retry client errors (400, 401, etc.)
      }
    }
  }
  throw new Error("Unreachable");
}

Nøkkelprinsippene: prøv på nytt med 429- og 5xx-feil med eksponentiell backoff, gå videre til neste modellleverandør når forsøkene er brukt opp, og ha alltid en endelig fallback (cachet svar, statisk innhold eller en tydelig feilmelding). La aldri en AI-feil krasje appen din.

Slik jobber Techsy med AI-funksjonsutvikling

Vi starter hvert AI-prosjekt med det samme spørsmålet fra seksjon 3: "Trenger dette faktisk en LLM, eller finnes det en enklere løsning?" Du ville bli overrasket over hvor ofte svaret er "en godt designet SQL-spørring håndterer 80% av dette".

Når AI er riktig valg, her er vår prosess:

1. Prototyp raskt — fungerende proof-of-concept på 1-2 uker med gpt-4o-mini og den enklest mulige arkitekturen
2. Mål med ekte brukere — ikke syntetiske benchmarks, ekte brukertilfredshet (tommel opp/ned, oppgaveklararingshastighet)
3. Iterer med evalueringer — automatiserte LLM-evalueringer som fanger opp kvalitetsregresjoner før brukerne gjør det
4. Herding for produksjon — hastighetsbegrensninger, fallback-kjeder, kostnadsovervåking og sikkerhetsmønstrene fra denne guiden
5. Optimaliser kostnader — modellruting, prompt-caching og riktig størrelse på modeller per funksjon

Hva du kan forvente på ekte prosjekter: veiledning fra offentlige benchmarks

Vi publiserer ikke kundedata uten tillatelse, men følgende tall er forankret i publiserte modellbenchmarks og offentlige API-prisdata — nyttige som tekniske referansepunkter før du har dine egne målinger:

• Streaming first-token-latens med gpt-4o-mini lander typisk mellom 200ms og 600ms under normal belastning. gpt-4o er lignende eller noe høyere. Forvent at p95 er 1,5-2 ganger medianen.
• Kostnad per samtale for et typisk 600-token støttesvar (400 inndata + 200 utdata) på gpt-4o-mini: (400/1 000 000 × $0,15) + (200/1 000 000 × $0,60) = $0,000060 + $0,000120 = $0,00018 per svar, under en øre selv ved 5 000 svar per dag.
• RAG-overhead: å embedde hver forespørsel via text-embedding-3-small ($0,02/1M tokens) legger til omtrent $0,000010 per søk, ubetydelig sammenlignet med completion-anropet.

Disse er representative utgangspunkter. Hvis du instrumenterer dine egne anrop vil faktiske tall variere avhengig av promptlengde, systemmeldingsstørrelse og trafikktopper. Hvis du har kjørt Techsy-bygde integrasjoner og ønsker å dele benchmarkdata for denne guiden, kontakt oss.

Vi har bygget streaming AI-chatter, RAG-drevne kunnskapsbaser og AI-drevne klassifiseringssystemer for SaaS-produkter. Mønstrene i denne guiden er de samme vi bruker i kundeprosjekter — ingenting er skjult.

Bygger du AI-funksjoner og trenger en second opinion? Få en gratis arkitekturgjennomgang.

Vanlige spørsmål

Hvordan legger jeg til AI-funksjoner i SaaS-en min uten å bygge om fra bunnen?

Du bygger ikke om. Du legger til en backend API-rute som kaller OpenAI eller Anthropic, kobler det til eksisterende UI og distribuerer. Kodeeksemplene i denne guiden viser nøyaktig det — et nytt endepunkt, ikke en ny arkitektur. Begynn med én funksjon som chat eller sammendrag og bygg deretter videre derfra.

Hva er den raskeste måten å integrere OpenAI i en eksisterende app?

Installer SDK-et (pip install openai eller npm install openai), opprett en backend API-rute, kall chat.completions.create() og returner resultatet. Med useChat-hooken i Vercel AI SDK kan du ha streaming AI-chat i gang på under 30 minutter.

Hvor mye koster det å legge til AI-funksjoner i en SaaS-app?

API-kostnader for en app med 1 000 brukere varierer fra $15-150/måned avhengig av modell og bruksmønstre. gpt-4o-mini på $0,15/1M inndatatokens holder kostnadene meget lave. Utviklingstiden er typisk 1-4 uker for den første funksjonen. Se tokenbudsjettseksjonen for detaljerte scenarioer.

Bør jeg bruke RAG eller fine-tuning for å legge til AI i produktet mitt?

RAG for 90% av brukstilfellene. Fine-tuning bare når du trenger at modellen lærer en spesifikk stil eller domenekunnskap som ikke kan gis via kontekst. RAG er billigere, raskere å implementere og mye lettere å oppdatere — du legger bare til nye dokumenter i vektorlageret i stedet for å trene opp en modell på nytt.

Hvordan unngår jeg å eksponere OpenAI API-nøkkelen min i en webapp?

Kall aldri OpenAI API fra frontenden. Opprett en backend-proxy — frontenden din kaller API-et ditt, backenden din kaller OpenAI. Lagre nøkkelen i serversidede miljøvariabler. Legg til hastighetsbegrensning per bruker slik at ingen kan misbruke endepunktet ditt.

Hvor lang tid tar det å legge til AI-funksjoner i en eksisterende app?

En grunnleggende chat-funksjon tar 1-2 dager. Streaming-UI legger til 2-3 dager. RAG med bedriftens data tar 1-2 uker. Full produksjonsherdning med hastighetsbegrensninger, feilhåndtering og kostnadskontroller tar 2-4 uker. Du kan lansere grunnversjonen på dager og iterere derfra.

Når bør jeg bruke GPT-4o vs Claude vs Gemini?

GPT-4o for generelle oppgaver med det største økosystemet og beste verktøystøtten. Claude Sonnet 4.6 for lange dokumenter, nøyaktig instruksjonsfølging og kodeoppgaver. Gemini 2.5 Pro for multimodalt arbeid (bilder + tekst) og Google Cloud-integrering. Begynn med GPT-4o-mini for kostnadsbesparelser — oppgrader bare når du kan måle en kvalitetsforskjell.

Hvordan håndterer jeg AI-feil i produksjon?

Implementer retry-logikk med eksponentiell backoff for 429 (hastighetsbegrensning) og 5xx-feil. Bygg en fallback-modellkjede — prøv primærmodellen din, fall tilbake til en alternativ leverandør og deretter til et cachet eller statisk svar. La aldri en AI-feil krasje appen din eller vise en tom skjerm.

Hvilke AI-funksjoner bør en SaaS-app ha i 2026?

Begynn med den høyeste verdi, laveste kompleksitet-funksjonen for det spesifikke produktet ditt. For de fleste SaaS-apper: AI-drevet søk, innholdssammendrag eller en innebygd assistent. Se hurtigoversiktstabellen i begynnelsen av denne guiden for kostnads- og vanskelighetsestimater per funksjonstype.

Hvordan vet jeg om AI-funksjonen min faktisk fungerer?

Sett opp LLM-evalueringer — automatiserte tester som måler svarkvalitet, relevans og sikkerhet på et sett med representative indata. Spor brukertilfredshetsmålinger som tommel opp/ned-vurderinger og frekvensen av oppfølgingsspørsmål. Sammenlign AI-assistert oppgaveklaring med det AI-frie flytet. Hvis brukerne ikke fullfører oppgaver raskere eller mer vellykket, trenger funksjonen forbedring.

Sjekklisten din for å lansere AI-funksjonen din

Nå har du hele bildet. Her er din trinn-for-trinn-vei til lansering:

1. Velg funksjonen din — bruk hurtigoversiktstabellen for å velge det høyeste verdi, laveste vanskelighets-alternativet for produktet ditt
2. Kjør regex-testen — bekreft at AI faktisk er riktig verktøy for denne oppgaven
3. Begynn med en billig modell — gpt-4o-mini eller claude-haiku-4.5, mål kvaliteten før du oppgraderer
4. Bygg det grunnleggende API-anropet — Python eller TypeScript, bak en backend-proxy
5. Legg til streaming — Vercel AI SDK gjør dette trivielt for React-apper
6. Legg til strukturerte outputs — hvis funksjonen din trenger tolkbar data, ikke fritekst
7. Beregn tokenbudsjettet ditt — brukere × forespørsler × tokens × kostnad = månedlig regning
8. Implementer hastighetsbegrensninger og feilhåndtering — grenser per bruker, retry-logikk, fallback-kjede
9. Distribuer og mål — spor brukertilfredshet, ikke bare om API-et returnerer 200

Den første AI-funksjonen din er nærmere enn du tror. Den vanskeligste delen er ikke koden — det er å bestemme hvilken funksjon du skal bygge først. Velg én, lanser den denne uken og iterer basert på hva ekte brukere forteller deg.

Kilder

• OpenAI API-prissetting
• Anthropic Claude API-prissetting
• Vercel AI SDK — Streaming
• OpenAI Strukturerte Outputs-guide
• OpenAI Produksjonsbeste praksiser
• OWASP Top 10 for LLM-applikasjoner 2025
• Anthropic Tool Use-dokumentasjon
• LangChain RAG-veiledning
• LlamaIndex Introduksjon til RAG