01_basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0",
   "metadata": {},
   "source": [
    "# 🦜🔗 Langchain Demo\n",
    "\n",
    "Hallo und herzlich Willkommen!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1",
   "metadata": {},
   "source": [
    "## Überblick\n",
    "\n",
    "### OpenAI-Modelle\n",
    "\n",
    "ChatGPT oder auch jedes andere LLM benutzen ist relativ einfach mit Langchain\n",
    "\n",
    "Für den Anfang nutzen wir das \"gpt-4o\" Model - einige nennenswerte Modelle von OpenAI sind:\n",
    "\n",
    "- `gpt-35-turbo` das günstigste und am historisch am weitesten verbreitete Modell, mit dem Chat-GPT bekannt geworden ist\n",
    "- `gpt-4-turbo` Turbo-Variante von gpt-4 (günstiger, schneller, kleinere maximale Länge des Text-Outputs)\n",
    "- `gpt-4-vision` ein \"multimodales\" Modell, welches auch Bilder lesen kann.\n",
    "- `gpt-4o` die neueste multimodale Variante von gpt-4. In vielen Aspekten besser, in manchen schlechter als die alten Modelle.\n",
    "- `gpt-4o-mini` ein kostengünstiger kleiner Bruder von gpt-4o\n",
    "- `o1-preview` ein extrem intelligentes und teures 'Modell' (Eigentlich ein Agent)\n",
    "\n",
    "OpenAI trainiert diese Versionen laufend neu, was dazu führen kann, dass Anfragen an das LLM plötzlich andere Antworten geben.\n",
    "Möchte man dies verhindern, kann man seine Applikation auf einen Snapshot (z. B. gpt-4-0613) festsetzen.\n",
    "Dies ist insbesondere wichtig, wenn die Applikation vom Output des LLM bestimmte Strukturen erwartet, etwa eine bestimmte XML-Syntax o.Ä.\n",
    "\n",
    "OpenAI-Modelle werden nicht nur von OpenAI selbst gehostet, sondern auch von Azure.\n",
    "Diese muss man auf dem Azure Portal selbst als Endpunkte konfigurieren, in der Regel leiden die OpenAI Azure Deployments weniger unter hoher Auslastung\n",
    "\n",
    "### Andere Modelle\n",
    "\n",
    "Auch wenn wir nicht damit arbeiten werden, ist es vielleicht relativ gut, die Namen der \"großen\" Konkurrenz-Modelle einmal gehört zu haben:\n",
    "\n",
    "- `Gemini` das neueste Google-Modell. Es hat den Fokus vornehmlich auf multimodalem Input.\n",
    "- `Claude` Claude ist die LLM-Reihe von Anthropic. Enorme Kontextlänge, oft beeindruckende Ergebnisse, teuer.\n",
    "- `Mistral` ein kleines, offenes Modell von Mistral AI, auf fast jeder Hardware selbst betreibbar.\n",
    "- `Mistral large` das kommerzielle Angebot von Mistral\n",
    "- `Mixtral` ein hervorragendes Open-Source Modell von Mistral AI. Ein guter Kandidat für ein selbst gehostetes LLM.\n",
    "- `LLama 3` das aktuelle Modell von Meta, das in einigen Bereichen an die Performance von GPT-4 heranreicht.\n",
    "\n",
    "### DSGVO - konform?\n",
    "\n",
    "Gerücht aus den Anfangstagen von AI. Inzwischen sind alle großen Modelle DSGVO-konform betreibbar.\n",
    "\n",
    "### Aleph Alpha\n",
    "\n",
    "Stand 2024 Anfang: Das aktuelle Aleph Alpha ist ein \"last generation\" Sprachmodell, das auch zu kleinen modernen Modellen wie Mistral 7B nicht mehr konkurrenzfähig ist.\n",
    "\n",
    "### Temperatur\n",
    "\n",
    "Alle LLMs sind nicht deterministisch. Aber die Temperatur ist ein Parameter, mit der man die Variabilität von Antworten hoch und runterschrauben kann.\n",
    "Wie bei normalen Atomen ist die Bewegung niedrig, wenn die Temperatur niedrig ist. Wenn man die Temperatur hochschraubt, wird viel gewackelt.\n",
    "Der Temperatur-Parameter ist üblicherweise ein Fließkommawert zwischen 0 und 1.\n",
    "\n",
    "### Bitte etwas schneller\n",
    "\n",
    "Recht neu auf dem Markt mit beeindruckendem Token/Sekunde-Verhältnis: [Groq](https://groq.com/)\n",
    "\n",
    "### Links:\n",
    "\n",
    "- https://python.langchain.com/docs/get_started/introduction\n",
    "- https://platform.openai.com/docs/models/\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2",
   "metadata": {},
   "source": [
    "#### Wir probieren aus:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from helpers import llm\n",
    "\n",
    "print(\n",
    "    llm()\n",
    "    .invoke(\n",
    "        \"Hi OpenAI! Kannst du mir einen Trinkspruch auf Würzburg im fränkischen Dialekt sagen?\"\n",
    "    )\n",
    "    .content\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4",
   "metadata": {},
   "source": [
    "#### Jetzt nochmal mit Streaming. Dazu rufen wir nicht invoke sondern astream auf (a für async). Wir drehen etwas an der Temperatur, damit die Ergebnisse spannend bleiben\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5",
   "metadata": {},
   "outputs": [],
   "source": [
    "chunks = []\n",
    "async for chunk in llm(temperature=1).astream(\n",
    "    \"Erkläre in einem Satz Quantenmechanik für 4jährige, ohne dabei Details auszulassen.\"\n",
    "):\n",
    "    chunks.append(chunk)\n",
    "    print(chunk.content, end=\"\", flush=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6",
   "metadata": {},
   "source": [
    "## Token\n",
    "\n",
    "Token sind die kleinste Einheit des LLM. Das haben wir gerade beim Streaming schön gesehen. Der Stream kommt Token für Token aus dem LLM gepurzelt.\n",
    "\n",
    "Das LLM rechnet aus der Eingabe und den bisher errechneten Token die Wahrscheinlichkeit für den nächsten Token aus. Dieser neue Token wird dann angehängt und der nächste Token wird ermittelt.\n",
    "\n",
    "So geht das immer weiter. Bis der nächste wahrscheinlichste Token ein Stop-Zeichen ist. Auf diese Weise generieren LLMs die wahrscheinlichste Fortführung der Eingabetoken.\n",
    "\n",
    "Token können Wörter, machmal sogar Wortgruppen oder auch nur einzelne oder mehrere Buchstaben sein.\n",
    "\n",
    "Die Bepreisung der LLMs ist an die Tokenanzahl (Eingabe und Ausgabe) gekoppelt.\n",
    "\n",
    "Links:\n",
    "\n",
    "- https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tiktoken\n",
    "\n",
    "encoding = tiktoken.encoding_for_model(\"gpt-4o\")\n",
    "\n",
    "tokens = encoding.encode(\"AI ist eine tolle Sache.\")\n",
    "print(tokens)\n",
    "\n",
    "decoded_tokens = [\n",
    "    encoding.decode_single_token_bytes(token).decode(\"utf-8\") for token in tokens\n",
    "]\n",
    "for token in decoded_tokens:\n",
    "    print(token)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8",
   "metadata": {},
   "source": [
    "## ✅ Aufgabe\n",
    "\n",
    "Aus welchen Token besteht der String \"Berlin\"?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9",
   "metadata": {},
   "outputs": [],
   "source": [
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10",
   "metadata": {},
   "source": [
    "## Prompt Engineering und Templates in Langchain\n",
    "\n",
    "Um die Dinge von der AI zu bekommen, die man erwartet, stellt man am besten sehr konkrete und präzise Anfragen.\n",
    "\n",
    "Weil eine AI oft an ein bestimmtes Feld von Aufgaben gekoppelt ist, gibt man die Rahmenanweisung dann in ein Template ein, um nicht immer wieder die gleiche Rahmenanweisung zu schreiben.\n",
    "\n",
    "Die jeweilige konkrete Nutzeranfrage wird dann in das Template eingefügt und das ausgefüllte Template ans LLM übergeben.\n",
    "\n",
    "Der Trend geht immer mehr zu Chat-Modellen. Hierbei ist die Information, die man dem LLM gibt, in \"Messages\" unterteilt. Besondere Gewichtung hat eine System-Message. Diese kann Rahmenanweisungen enthalten, an die sich das LLM halten soll. Dem Nutzer wird es schwer fallen, das LLM dazu zu bewegen, sich über eine Anweisung in der System-Message hinweg zu setzen. Das LLM wurde ganz einfach darauf trainiert, sich an die Anweisungen einer System-Message strikt zu halten.\n",
    "\n",
    "### Links\n",
    "\n",
    "- https://python.langchain.com/docs/get_started/quickstart#prompt-templates\n",
    "- https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/prompt-engineering\n",
    "- https://learnprompting.org/docs/intro\n",
    "- https://www.promptingguide.ai/\n",
    "- https://smith.langchain.com/hub\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.prompts import ChatPromptTemplate\n",
    "\n",
    "prompt = ChatPromptTemplate.from_messages(\n",
    "    [\n",
    "        (\"system\", \"Du bist eine hilfsbereiter {beruf} aus Würzburg.\"),\n",
    "        (\n",
    "            \"human\",\n",
    "            \"Erkläre in 2 Sätzen im lokalen Dialekt warum Deine Kunden aus {ort} die besten sind.\",\n",
    "        ),\n",
    "    ]\n",
    ")\n",
    "\n",
    "print(prompt.format(beruf=\"Entwickler\", ort=\"Würzburg\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12",
   "metadata": {},
   "source": [
    "### Langchain Hub Beispiel\n",
    "\n",
    "Weil das \"Prompt-Engineering\" ein bisschen Übung braucht und es diverse Tricks gibt, hat LangChain einen \"Hub\", auf dem man eine ganze Reihe vorgefertigter Prompts für verschiedene Anwendungsfälle findet.\n",
    "\n",
    "Dort kann man sich inspirieren lassen, Prompts forken oder auch selbst etwas für andere Leute zur Verfügung stellen, wenn es sich als nützlich erweist.\n",
    "\n",
    "Links:\n",
    "\n",
    "- https://smith.langchain.com/hub/borislove/customer-sentiment-analysis\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain import hub\n",
    "\n",
    "sentiment_prompt = hub.pull(\"borislove/customer-sentiment-analysis\")\n",
    "\n",
    "client_letter = \"\"\"Ich bin von dem Volleyballschläger zutiefst enttäuscht. Zuerst ist der Griff abgefallen, danach auch noch der Dynamo. Außerdem riecht er noch schlechter als er schmeckt. Wieso ist das immer so ein Ärger mit euch?\"\"\"\n",
    "format_instructions = \"\"\"Zusätzlich zur numerischen Klassifizierung sollst du herausfinden, was der Kunde gerne gehabt hätte. Antworte auf deutsch.\"\"\"\n",
    "\n",
    "print(\n",
    "    sentiment_prompt.format(\n",
    "        client_letter=client_letter, format_instructions=format_instructions\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14",
   "metadata": {},
   "source": [
    "## Jetzt fängt es an, etwas technischer zu werden. Wieso heißt LangChain eigentlich LangChain?\n",
    "\n",
    "Langchain definiert einige Python-Operatoren neu, wenn sie zwischen LangChain-Objekten stehen. Der bekannteste ist die Pipe: |\n",
    "\n",
    "Wenn die Pipe zwischen zwei Langchain-Objekten steht, wird die Ausgabe des ersten Obekts an das nächste weitergegeben. Damit erhält man eine \"Chain\" von \"Runnables\"\n",
    "\n",
    "#### Links\n",
    "\n",
    "- https://python.langchain.com/docs/modules/chains\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.schema import StrOutputParser  # Hilft beim Formatieren\n",
    "from helpers import llm\n",
    "\n",
    "chain = prompt | llm() | StrOutputParser()\n",
    "print(chain.invoke({\"beruf\": \"Winzer\", \"ort\": \"Würzburg]\"}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Streaming\n",
    "async for chunk in chain.astream({\"beruf\": \"Winzer\", \"ort\": \"Würzburg\"}):\n",
    "    print(chunk, end=\"\", flush=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Funktioniert auch das Beispiel vom Hub?\n",
    "sentiment_chain = sentiment_prompt | llm() | StrOutputParser()\n",
    "async for chunk in sentiment_chain.astream(\n",
    "    {\"client_letter\": client_letter, \"format_instructions\": format_instructions}\n",
    "):\n",
    "    print(chunk, end=\"\", flush=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wir können dynamisch die format_instructions des Templates überschreiben, um neue Ergebnisse zu bekommen\n",
    "sentiment_chain = sentiment_prompt | llm() | StrOutputParser()\n",
    "format_instructions = \"\"\"Zusätlich zur sentiment Analysis ist es deine Aufgabe, die Sinnhaftigkeit der Kundenäußerung zu überprüfen.\"\"\"\n",
    "async for chunk in sentiment_chain.astream(\n",
    "    {\"client_letter\": client_letter, \"format_instructions\": format_instructions}\n",
    "):\n",
    "    print(chunk, end=\"\", flush=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19",
   "metadata": {},
   "source": [
    "## ✅ Aufgabe\n",
    "\n",
    "An Stelle der Frage nach Sinnhaftigkeit soll eine Vorschlag gemacht werden, was man dem Kunden antworten kann.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20",
   "metadata": {},
   "outputs": [],
   "source": [
    "format_instructions = \"\"\"[CHANGE HERE]\"\"\"\n",
    "async for chunk in sentiment_chain.astream(\n",
    "    {\"client_letter\": client_letter, \"format_instructions\": format_instructions}\n",
    "):\n",
    "    print(chunk, end=\"\", flush=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21",
   "metadata": {},
   "source": [
    "### Debug Informationen gewünscht?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.globals import set_debug"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Und jetzt selber mal Ausprobieren\n",
    "set_debug(True)\n",
    "print(chain.invoke({\"beruf\": \"Programmierer\", \"ort\": \"[INSERT]\"}))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".virtualenv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}