Llama 3 lokaal draaien met Ollama en GPT4ALL

Waarom Llama 3 lokaal draaien?

Llama 3 lokaal draaien lijkt misschien intimiderend vanwege de hoge RAM-, GPU- en rekenvereisten. Dankzij vooruitgang in frameworks en modeloptimalisatie is het echter toegankelijker dan ooit. Dit is waarom je het zou overwegen:

• Ononderbroken toegang: Je hoeft je geen zorgen te maken over ratelimieten, downtime en onverwachte storingen.
• Betere performance: Antwoorden worden snel gegenereerd, zonder haperingen of vertraging. Zelfs op middenklasse laptops haal je snelheden van ongeveer 50 tokens per seconde.
• Verbeterde veiligheid: Je hebt volledige controle over de inputs die worden gebruikt om het model te fine-tunen, en de data blijft lokaal op je apparaat.
• Lagere kosten: In plaats van hoge kosten te betalen voor API-toegang of een online chatbotabonnement, kun je Llama 3 gratis gebruiken.
• Aanpasbaarheid en flexibiliteit: Je kunt modellen aanpassen met hyperparameters, stop tokens toevoegen en geavanceerde instellingen wijzigen.
• Offline mogelijkheden: Zodra je het model hebt gedownload, heb je geen internetverbinding nodig om het te gebruiken.
• Eigenaarschap: Je hebt volledige eigendom en controle over het model, de data en de outputs.

Lees ons artikel, The Pros and Cons of Using Large Language Models (LLMs) in the Cloud vs. Running LLMs Locally, om te ontdekken of LLM’s lokaal gebruiken bij je past.

Llama 3 gebruiken met GPT4ALL

GPT4ALL is opensourcesoftware waarmee je populaire grote taalmodellen op je lokale machine kunt draaien, zelfs zonder GPU. Het is gebruiksvriendelijk en daardoor ook toegankelijk voor niet-technische gebruikers.

We beginnen met het downloaden en installeren van GPT4ALL op Windows via de officiële downloadpagina.

Na de installatie start je de applicatie en klik je op de knop “Downloads” om het modellenmenu te openen. Scroll naar beneden, selecteer het model “Llama 3 Instruct” en klik vervolgens op de knop “Download”.

Als het downloaden klaar is, sluit je het tabblad en selecteer je het Llama 3 Instruct-model via het dropdownmenu “Choose a model”.

Typ een prompt en gebruik het net als ChatGPT. Het systeem heeft de CUDA-toolkit geïnstalleerd, dus er wordt een GPU gebruikt om sneller te reageren.

Llama 3 gebruiken met Ollama

Laten we nu de makkelijkste manier proberen om Llama 3 lokaal te gebruiken door Ollama te downloaden en te installeren.

Ollama is een krachtig hulpmiddel waarmee je LLM’s lokaal kunt gebruiken. Het is snel en zit boordevol functies.

Na de installatie van Ollama op je systeem, start je de terminal/PowerShell en typ je het commando.

ollama run llama3

Let op: Het downloaden van het modelbestand en het starten van de chatbot in de terminal duurt enkele minuten.

Schrijf prompts of stel vragen, en Ollama genereert het antwoord in je terminal. De chatreactie is supersnel en je kunt doorvragen om dieper op het onderwerp in te gaan.

Om de chatbot af te sluiten, typ je gewoon /bye.

Naast deze twee tools kun je ook de gids Run LLMs Locally: 7 Simple Methods raadplegen voor meer applicaties en frameworks.

Llama 3 lokaal serven

Door een lokale server te draaien kun je Llama 3 integreren in andere applicaties en je eigen toepassing bouwen voor specifieke taken.

Start de lokale model-inference-server door het volgende commando in de terminal te typen.

ollama serve

Om te controleren of de server goed draait, ga je naar het systeembak, zoek je het Ollama-icoon en klik je met de rechtermuisknop om de logs te bekijken.

Je komt in de Ollama-map, waar je het bestand `server.log` kunt openen om informatie te zien over serververzoeken via API’s en serverinformatie met tijdstempels.

De API benaderen met CURL

Je kunt de inference-server eenvoudig benaderen met het CURL-commando.

Geef gewoon de modelnaam en prompt op, en zet streaming uit om het volledige bericht te krijgen.

curl http://localhost:11434/api/chat -d '{
  "model": "llama3",
  "messages": [
    { "role": "user", "content": "What are God Particles?" }
  ],
  "stream": false
}'

Het CURL-commando is standaard op Linux, maar je kunt het ook in Windows PowerShell gebruiken, zoals hieronder te zien is.

De API benaderen met de Python-package

Je kunt ook de Ollama Python-package met PIP installeren om de inference-server te benaderen.

pip install ollama

Met de API in Python heb je de kracht om AI-toepassingen en tools te bouwen, en het is supermakkelijk in gebruik.

Geef de functies `ollama.chat` simpelweg de modelnaam en het bericht, en er wordt een antwoord gegenereerd.

Let op: In het message-argument kun je ook een systeemprompt en assistantprompt toevoegen om context mee te geven.

import ollama

response = ollama.chat(
    model="llama3",
    messages=[
        {
            "role": "user",
            "content": "Tell me an interesting fact about elephants",
        },
    ],
)
print(response["message"]["content"])

De Ollama Python-package biedt ook functies zoals asynchrone aanroepen en streaming, waarmee je API-verzoeken efficiënt beheert en de ervaren snelheid van het model verhoogt.

Net als met de OpenAI API kun je een asynchrone chatfunctie maken en vervolgens streamingcode schrijven met de async-functie, voor efficiënte en snelle interacties met het model.

import asyncio
from ollama import AsyncClient

async def chat():
    """
    Stream a chat from Llama using the AsyncClient.
    """
    message = {
        "role": "user",
        "content": "Tell me an interesting fact about elephants"
    }
    async for part in await AsyncClient().chat(
        model="llama3", messages=[message], stream=True
    ):
        print(part["message"]["content"], end="", flush=True)


asyncio.run(chat())

Zoals je ziet, toont het model de tokens terwijl ze worden gegenereerd.

Je kunt de Python-API ook gebruiken om een custom model te maken, tekst naar embeddings te converteren en foutafhandeling te doen. Ook kun je modellen kopiëren, verwijderen, pullen en pushen.

Llama 3 integreren in VSCode

Naast het gebruik van Ollama als chatbot of voor het genereren van antwoorden, kun je het integreren in VSCode en Llama 3 gebruiken voor functies zoals autocompletion, contextbewuste codesuggesties, code schrijven, docstrings genereren, unit tests maken en meer.

1. We moeten eerst de Ollama-inference-server initialiseren door het volgende commando in de terminal te typen.

ollama serve

2. Ga naar de VSCode-extensies, zoek de tool "CodeGPT" en installeer deze. Met CodeGPT kun je elke modelprovider koppelen met de API-sleutel.

3. Stel CodeGPT in door op het CodeGPT-chatpictogram in het linkerpaneel te klikken. Verander de modelprovider naar Ollama en selecteer het model llama3:8b. Je hoeft geen API-sleutel op te geven, omdat we het lokaal draaien.

4. Schrijf de prompt om Python-code te genereren en klik vervolgens op de knop "Insert the code" om de code in je Python-bestand te plakken. Je kunt ook vervolginstructies geven om de code te verbeteren.

5. Naast de code-assistent kun je CodeGPT gebruiken om code te begrijpen, te refactoren, te documenteren, unit tests te genereren en problemen op te lossen.

Wil je je een Python-pro voelen? Bekijk de gids Setting Up VSCode For Python om de kernfuncties van VSCode te leren kennen en het naar wens aan te passen.

Een AI-toepassing lokaal ontwikkelen

In deze sectie ontwikkelen we een AI-gestuurde applicatie die docx-bestanden uit een aangewezen map leest, ze omzet naar embeddings en opslaat in een vector store.

Daarna gebruiken we een similarity search om relevante betekenissen op te halen en contextuele antwoorden op je vragen te geven.

Met deze applicatie kun je snel de kern van boeken begrijpen en dieper ingaan op de karakterontwikkeling.

Installatie

Eerst installeren we alle benodigde Python-packages voor het laden van documenten, de vector store en LLM-frameworks.

pip install unstructured[docx] langchain langchainhub langchain_community langchain-chroma

Start daarna de Ollama-inference-server.

ollama serve

De documenten laden

Het is best practice om je code te ontwikkelen en testen in Jupyter Notebook voordat je de app maakt.

We laden alle docx-bestanden uit de map met de DirectoryLoader.

from langchain_community.document_loaders import DirectoryLoader

loader = DirectoryLoader("C:/Users/abida/Desktop/Books", glob="**/*.docx")
books = loader.load()
len(books)

4

Je kunt je eigen contextbewuste chatbot maken door de tutorial te volgen: Chatbot Development with ChatGPT & LangChain: A Context-Aware Approach.

De tekst splitsen

Een volledig boek aan het model voeren is niet haalbaar, omdat het de contextvenstergrootte overschrijdt. Om deze beperking te omzeilen, moeten we de tekst opdelen in kleinere, beheersbare stukken die comfortabel binnen het contextvenster van het model passen.

In ons geval converteren we alle vier boeken naar chunks van 500 tekens.

from langchain_text_splitters import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)
all_splits = text_splitter.split_documents(books)

Ollama-embeddings en Chroma-vector store

We gebruiken Langchain om de tekst naar embeddings te converteren en op te slaan in de Chroma-database.

We gebruiken het Ollama Llama 3-model als embeddingmodel.

from langchain_chroma import Chroma
from langchain_community.embeddings import OllamaEmbeddings

vectorstore = Chroma.from_documents(
    documents=all_splits,
    embedding=OllamaEmbeddings(model="llama3", show_progress=True),
    persist_directory="./chroma_db",
)

OllamaEmbeddings: 100%|██████████| 23/23 [01:00<00:00,  2.63s/it]

Laten we onze vectordatabase testen met een paar similarity searches.

question = "Who is Zahra?"
docs = vectorstore.similarity_search(question)
docs

We kregen vier resultaten die lijken op de vraag.

Je kunt je verdiepen in de wereld van vectordatabases en Chroma DB door de tutorial Learn How to Use Chroma DB: A Step-by-Step Guide te lezen.

Langchain-chains bouwen voor een Q&A-retrievalsysteem

Om een goed vraag-en-antwoord-retrievalsysteem te bouwen, gebruiken we Langchain-chains en voegen we modules toe.

In onze Q&A-chain zullen we

1. De vector store gebruiken als retriever en de resultaten formatteren.
2. Daarna geven we de RAG-prompt mee. Die kun je eenvoudig uit de Langchain Hub pullen.
3. Vervolgens leveren we de Ollama Llama 3-inferencefunctie.
4. Tot slot parsen we de resultaten zodat alleen de respons wordt weergegeven.

Simpel gezegd: voordat je vraag door het Llama 3-model gaat, voegen we context toe via de similarity search en de RAG-prompt.

from langchain import hub
from langchain_community.llms import Ollama
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

llm = Ollama(model="llama3")

retriever = vectorstore.as_retriever()


def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)


rag_prompt = hub.pull("rlm/rag-prompt")
qa_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

Je kunt een vergelijkbare applicatie bouwen met LLamaIndex. Volg daarvoor de tutorial LlamaIndex: A Data Framework for the Large Language Models (LLMs) based applications.

De Q&A-retrievalchain testen

Stel relevante vragen over boeken om meer over het verhaal te begrijpen.

question = "What is the story of the 'Gené is Missing' book?"
qa_chain.invoke(question)

Zoals we zien levert het gebruik van boeken als context een accuraat antwoord op.

'Based on the provided context, "Gené is Missing" appears to be a mystery novel that revolves around uncovering the truth about Gené\'s life and potential involvement in murders. The story follows different perspectives, including Simon trying to prove his innocence, flashbacks of Gené\'s past, and detective Jacob investigating the case.'

Laten we nu een vraag stellen over het personage.

question = "Who is Arslan?"
qa_chain.invoke(question)

Er werd een precies antwoord gegenereerd.

'Arslan is Zahra\'s brother\'s best friend. He is someone that Zahra visits in the book "A Boy with Honest Dreams" by Abid Ali Awan to gather information about Ali.'

De AI-toepassing bouwen

Om een volwaardige AI-toepassing te bouwen die naadloos in je terminal draait, combineren we alle code uit de vorige secties in één Python-bestand.

code AI_app.py

Daarnaast breiden we de code uit voor interactieve queries, zodat je de app herhaaldelijk vragen kunt stellen totdat je de sessie expliciet beëindigt door ‘exit’ te typen.

from langchain_chroma import Chroma
from langchain_community.embeddings import OllamaEmbeddings
from langchain import hub
from langchain_community.llms import Ollama
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

# loading the vectorstore
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=OllamaEmbeddings(model="llama3"))

# loading the Llama3 model
llm = Ollama(model="llama3")

# using the vectorstore as the retriever
retriever = vectorstore.as_retriever()

# formating the docs
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# loading the QA chain from langchain hub
rag_prompt = hub.pull("rlm/rag-prompt")

# creating the QA chain
qa_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

# running the QA chain in a loop until the user types "exit"
while True:
    question = input("Question: ")
    if question.lower() == "exit":
        break
    answer = qa_chain.invoke(question)

    print(f"\nAnswer: {answer}\n")

Voer de applicatie uit door `Python` en de bestandsnaam in de terminal te typen.

python AI_app.py

Dit is tof. We hebben onze eigen RAG-AI-applicatie lokaal gebouwd met een paar regels code.

Alle broncode voor deze tutorial is beschikbaar in de GitHub-repository kingabzpro/using-llama3-locally. Neem vooral een kijkje en vergeet de repo niet te sterren ⭐.

Conclusie

In deze tutorial hebben we geleerd hoe je Llama 3 lokaal op een laptop gebruikt. We hebben ook gekeken naar de inference-server en hoe we die kunnen inzetten om Llama 3 te integreren in VSCode.

Uiteindelijk hebben we het Q&A-retrievalsysteem gebouwd met Langchain, Chroma en Ollama. De data verliet het lokale systeem niet en je hoefde er geen cent voor te betalen. Naast eenvoudige applicaties kun je met dezelfde tools ook complexe systemen bouwen.

Wil je meer leren? Dan raad ik deze tutorials aan:

• How to Run Llama 3.2 1B on an Android Phone With Torchchat
• How to Set Up and Run Gemma 3 Locally With Ollama
• How to Set Up and Run DeepSeek-R1 Locally With Ollama