1. Video Generatie Modellen

Wan 2.1 / 2.2

• Beschrijving: De huidige standaard voor open-source video. Zeer stabiel in beweging en anatomie.
• Gebruik: Hoogwaardige cinematografie, realistische menselijke acties.
• GitHub (Model): Wan-Video/Wan2.1
• ComfyUI Node: kijai/ComfyUI-WanVideoWrapper

Hunyuan Video (v1.5)

• Beschrijving: Tencent's vlaggenschip model met 13 miljard parameters, nu in v1.5 met verbeterde prompt-adherentie en een "distilled" versie voor snelheid.
• Gebruik: Complexe tekstuele instructies en lange scènes.
• GitHub (Model): Tencent-Hunyuan/HunyuanVideo
• ComfyUI Node: kijai/ComfyUI-HunyuanVideoWrapper

LTX Video (LTXV)

• Beschrijving: Een DiT-gebaseerd model gericht op real-time generatie en efficiëntie op consumenten-GPU's.
• Gebruik: Snelle previews en real-time video-to-video transformaties.
• GitHub (Model): Lightricks/LTX-Video
• ComfyUI Node: Lightricks/ComfyUI-LTXVideo

Kandinsky 5.0 Video (Lite & Pro)

• Beschrijving: Een suite van modellen gebaseerd op de Cross-Attention Diffusion Transformer (CrossDiT). De Lite (2B) versie is razendsnel en draait op consumenten-GPU's, terwijl de Pro (19B) versie cinematografische 10-seconden clips genereert met complexe camerabewegingen.
• Gebruik: Veelzijdige videocreatie (Text-to-Video en Image-to-Video) met sterke ondersteuning voor diverse talen en artistieke stijlen.
• GitHub (Model): kandinskylab/kandinsky-5
• ComfyUI Template: Kandinsky 5 Video Workflow (Official)

Gespecialiseerde Video Fine-tunes

• SCAIL: Studio-grade karakteranimatie (pose-to-video) met 3D-consistentie.
  • GitHub: zai-org/SCAIL | ComfyUI: ComfyUI-SCAIL-Pose (onderdeel van WanVideoWrapper).
• MoCha: De standaard voor het naadloos vervangen van personages in bestaande video's.
  • GitHub: Orange-3DV-Team/MoCha | ComfyUI: Geïntegreerd in WanVideoWrapper.
• Nexus 1.3B : Beschrijving: Een gespecialiseerde fine-tune van de Wan 1.3B architectuur, ontwikkeld binnen het Nexus-project. Dit model is specifiek getraind op "Nexus-data" voor complexe menselijke bewegingen. Gebruik: Dans, vechtsporten en gym-oefeningen waarbij anatomische correctheid cruciaal is. GitHub (Model): PKU-YuanGroup/OpenS2V-Nexus ComfyUI Node: Ondersteund via de WanVideoWrapper.

2. Image Generatie Modellen

FLUX.2

• Beschrijving: De opvolger van FLUX.1. Biedt fotorealisme en tekst-rendering die commerciële modellen zoals Midjourney evenaart.
• Gebruik: Alles van marketingmateriaal tot complexe digitale kunst.
• GitHub (Model): black-forest-labs/flux2
• ComfyUI Node: city96/ComfyUI-GGUF (voor GGUF quantisaties).

Qwen Image 2512

• Beschrijving: Een geavanceerd model van Alibaba dat uitblinkt in het volgen van instructies voor afbeeldingsbewerking.
• Gebruik: Laag-gebaseerde bewerkingen en complexe composities.
• GitHub (Model): QwenLM/Qwen-Image
• ComfyUI Node: Gebruik de ComfyUI-Manager en zoek op "Qwen2-VL".

Z-Image (Turbo)

• Beschrijving: Een 6B parameter model van Alibaba dat in slechts 8 stappen resultaten van topniveau levert.
• Gebruik: Real-time generatie en systemen met beperkte hardware.
• GitHub (Model): Tongyi-MAI/Z-Image
• ComfyUI Node: Geïntegreerd via WanVideoWrapper of direct via diffusers.

Het bericht Overzichtskaart: Open-Source AI Video & Image Modellen (Januari 2026) verscheen eerst op Utilewebsites.

Wat is ComfyUI?

ComfyUI is een krachtige en modulaire visuele AI-engine die werkt met stable diffusion-workflows. In plaats van een gesloten interface krijgt u een grafiek- en knooppunten-gebaseerd canvas. Daarmee bouwt u uw eigen AI-pijplijnen door knooppunten te verbinden, te vertakken en aan te passen. Dit geeft u maximale vrijheid om precies de workflow te maken die u nodig hebt.

Test zelf de nieuwste modellen

Omdat AI-modellen zich zo snel ontwikkelen, wilt u ze natuurlijk direct kunnen uitproberen. Beschikt u over een pc met voldoende hardware — bijvoorbeeld een NVIDIA RTX-videokaart met minstens 8GB VRAM — dan kunt u ComfyUI lokaal installeren. Zo draait u de nieuwste modellen gewoon op uw eigen systeem, zonder wachtrijen of kosten per prompt.

Workflows opslaan, delen en hergebruiken

Wat ComfyUI extra krachtig maakt, is dat u niet alleen workflows kunt maken, maar ook eenvoudig opslaan en delen. Bestanden zoals afbeeldingen, video’s of 3D-modellen bevatten metadata waarmee de volledige workflow automatisch wordt herbouwd zodra u ze in ComfyUI sleept. Dit is ideaal voor samenwerking, het leren van anderen of gewoon om snel opnieuw te experimenteren.

Open-source en multiplatform

ComfyUI is volledig gratis en open-source, en beschikbaar voor Windows, Linux en macOS. Of u nu een creatieve maker bent die visueel wil experimenteren, of een developer die technisch de diepte in wil: de tool past zich aan uw workflow aan.

Waarom kiezen voor ComfyUI?

• Flexibel en modulair: bouw uw eigen AI-workflows.
• Toekomstbestendig: test gemakkelijk de nieuwste modellen.
• Lokaal draaien: geen cloudkosten of afhankelijkheid.
• Community-driven: deel, remix en hergebruik workflows.

Kortom: wilt u écht de regie in handen nemen over AI-creatie, en alle nieuwe modellen die elke week verschijnen zelf ontdekken? Dan is ComfyUI dé engine om mee aan de slag te gaan.

Download ComfyUI via de officiële website: https://www.comfy.org/

Het bericht Ontdek ComfyUI: de modulaire visuele AI-engine voor creatieve workflows verscheen eerst op Utilewebsites.

Wilt u experimenteren met Large Language Models (LLM's) zonder afhankelijk te zijn van cloud-diensten? Met Ollama kunt u krachtige open-source taalmodellen direct op uw eigen computer draaien. Dit garandeert niet alleen uw privacy, maar geeft u ook volledige controle over uw data en de modellen die u gebruikt. In dit artikel leggen we stap voor stap uit hoe u Ollama installeert, een LLM lokaal kunt gebruiken en hoe u dit kunt integreren met populaire ontwikkelaarstools zoals LangChain en Visual Studio Code.

Wat is Ollama?

Ollama is een tool die het proces van het downloaden, opzetten en draaien van LLM's, zoals Llama 3, aanzienlijk vereenvoudigt. Het verpakt modelgewichten en configuraties in één bestand, vergelijkbaar met hoe Docker werkt voor applicaties. Dit maakt het voor zowel ontwikkelaars als enthousiastelingen gemakkelijk om met LLM's aan de slag te gaan.

Systeemvereisten

Voordat u begint, is het belangrijk om te controleren of uw systeem aan de minimale vereisten voldoet. Voor het draaien van kleinere modellen (rond 7 miljard parameters) wordt het volgende aangeraden:

• RAM: Minimaal 8 GB, maar 16 GB wordt aanbevolen voor betere prestaties.
• Opslag: Voldoende vrije schijfruimte voor de modellen, die enkele gigabytes groot kunnen zijn.

Voor grotere modellen heeft u aanzienlijk meer RAM en mogelijk een krachtige videokaart (GPU) nodig.

Installatie

Ollama is beschikbaar voor Windows, macOS en Linux.

1. Download Ollama: Ga naar de officiële website van Ollama op https://ollama.com/ en download het installatiebestand voor uw besturingssysteem.
2. Installeer Ollama: Voer het gedownloade bestand uit en volg de installatie-instructies. Na de installatie draait Ollama op de achtergrond.

Een model downloaden en draaien

1. Open de terminal:
   • Windows: Open het Startmenu, typ cmd of Terminal en druk op Enter.
   • macOS: Open de Terminal-app vanuit de map Hulpprogramma's.
   • Linux: Open uw favoriete terminal-emulator.
2. Download een model: Kies een model uit de Ollama-bibliotheek (te vinden op https://ollama.com/library). Een populair en krachtig model om mee te beginnen is Llama 3.1. U downloadt het met het volgende commando:

ollama pull llama3.1

Dit kan even duren, afhankelijk van de grootte van het model en uw internetsnelheid.

3. Draai het model: Zodra de download voltooid is, kunt u het model direct in uw terminal gebruiken met het volgende commando:

ollama run llama3.1

Interactie en Handige Commando's

Na het run commando kunt u direct beginnen met het stellen van vragen of het geven van opdrachten aan het model. U chat als het ware met de LLM in uw terminal.

• ollama list: Toont een lijst van alle modellen die u lokaal heeft gedownload.
• ollama rm <modelnaam>: Verwijdert een specifiek model om schijfruimte vrij te maken.
• /bye: Sluit de huidige chatsessie met een model.

Integratie met LangChain

LangChain is een populair framework voor het bouwen van applicaties met LLM’s. U kunt uw lokaal draaiende Ollama-model eenvoudig integreren in zowel Python- als JavaScript/TypeScript-projecten.

Python

1. Installeer de Python-package:

pip install langchain-ollama

2. Gebruik in uw code:

from langchain_ollama import ChatOllama

llm = ChatOllama(model="llama3.1")
response = llm.invoke("Wat is de hoofdstad van Nederland?")
print(response.content)

Node.js (JavaScript/TypeScript)

LangChain is ook beschikbaar voor JavaScript/TypeScript, ideaal voor back-ends (Node.js) of front-end frameworks (zoals Vue.js, React of Svelte).

1. Installeer via npm of yarn:

# Voor npm
npm install @langchain/ollama

# Voor yarn
yarn add @langchain/ollama

2. Gebruik in uw code:

import { ChatOllama } from "@langchain/ollama";

async function main() {
  const llm = new ChatOllama({ model: "llama3.1" });
  const response = await llm.invoke("Wat is de hoofdstad van Nederland?");
  console.log(response.content);
}

main();

Zo kunt u zowel in uw Python-backend als in uw JavaScript-stack naadloos schakelen tussen cloud-providers en uw eigen lokale Ollama-instance.

Integratie met Visual Studio Code

U kunt uw lokaal draaiende LLM ook gebruiken als aanvulling op uw ontwikkelomgeving in Visual Studio Code. Dit geeft u de mogelijkheid om code te genereren en vragen te stellen met uw eigen, lokaal gehoste model.

1. Zorg dat Ollama draait: Het Ollama-proces moet op de achtergrond actief zijn.
2. Installeer een compatibele extensie: Zoek in de VS Code Marketplace naar een extensie die Ollama-integratie biedt, zoals Continue.
3. Configureer de extensie: Volg de instructies van de extensie om Ollama als provider in te stellen en selecteer het model dat u wilt gebruiken (bijvoorbeeld llama3.1).

Nu kunt u in de chat-interface van de extensie uw lokale model aanroepen voor code-suggesties en andere programmeertaken, volledig binnen uw eigen omgeving.

Conclusie

Ollama maakt het lokaal draaien van LLM's toegankelijk voor een breed publiek. Of u nu een ontwikkelaar bent die een AI-toepassing wil bouwen met LangChain, of uw programmeerworkflow in VS Code wilt verbeteren, met Ollama kunt u snel en eenvoudig aan de slag. Door de actieve community en de voortdurende ontwikkeling is Ollama een uitstekende keuze voor iedereen die de wereld van lokale AI wil verkennen.

Het bericht Draai een Large Language Model (LLM) lokaal met Ollama verscheen eerst op Utilewebsites.

Met LM Studio kunt u lokale AI-modellen (LLMs) draaien op uw eigen computer, zonder cloud-services zoals OpenAI. In deze gids leert u hoe u LM Studio installeert, een LLM downloadt, test, en hoe u de API-server opstart om het model in uw eigen applicaties te gebruiken.

1. LM Studio downloaden en installeren

LM Studio wordt geleverd als een AppImage, een zelfstandig uitvoerbaar bestand. Volg deze stappen om het te installeren:

1. Download LM Studio
   • Ga naar lmstudio.ai en download de Linux AppImage.
   • Bewaar het bestand in een map zoals ~/Applications/.
2. Maak het bestand uitvoerbaar
   Open een terminal en voer het volgende commando uit: chmod +x ~/Applications/LM-Studio-*.AppImage
3. Start LM Studio ~/Applications/LM-Studio-*.AppImage. U kunt LM Studio nu gebruiken, maar laten we ervoor zorgen dat het ook in uw applicatiemenu staat.

2. LM Studio toevoegen aan het applicatiemenu

Maak een .desktop-bestand zodat LM Studio in uw menu verschijnt:

nano ~/.local/share/applications/LM-Studio.desktop

Plak deze inhoud en pas het pad aan:

[Desktop Entry]
Type=Application
Name=LM Studio
Exec=/home/user/Applications/LM-Studio-0.3.8-4-x64.AppImage --no-sandbox
Icon=/home/user/Applications/lmstudio-icon.png
Terminal=false
Categories=Development;AI;

Sla op met CTRL+O, sluit met CTRL+X, en update het menu:

update-desktop-database ~/.local/share/applications

Nu kunt u LM Studio openen vanuit het menu!

3. Een lokaal LLM-model downloaden

1. Open LM Studio en ga naar Model Search.
2. Zoek bijvoorbeeld Llama 3.2 1B Instruct (lichtgewicht en goed voor beginners).
3. Selecteer een Q4_K_M of Q8_0 kwantisatie (hoe lager de bitwaarde, hoe minder RAM-verbruik).
4. Wacht tot de download is voltooid.

4. Testen of het model werkt

• Ga naar Chats in LM Studio.
• Kies een nieuw gesprek en selecteer het geladen model.
• Typ vragen zoals: "Wat is de hoofdstad van Frankrijk?" "Leg kwantummechanica uit in simpele taal." "Wat is LLM model Llama-3.3-1B?"
• Als het model antwoordt, werkt alles!

5. De LLM API-server starten voor gebruik in uw eigen app

Wilt u LM Studio integreren in uw eigen Python-app of chatbot? Start dan de lokale server:

1. Open LM Studio en zet "Developer mode" aan.
2. Klik op "Start Server" (de server draait dan op http://127.0.0.1:1234).
3. Test of het werkt: curl http://127.0.0.1:1234/v1/models

6. Voorbeeld: LLM gebruiken in een Python-app

Hier is een voorbeeld van hoe u een API-aanroep doet naar uw lokale LLM:

import requests

url = "http://127.0.0.1:1234/v1/chat/completions"
headers = {"Content-Type": "application/json"}
data = {
    "model": "llama-3.2-1b-instruct",
    "messages": [{"role": "user", "content": "Wat is de hoofdstad van Frankrijk?"}]
}

response = requests.post(url, json=data, headers=headers)
print(response.json())

Om een JSON-geformatteerd POST-verzoek in PHP te verzenden om te communiceren met de API van LM Studio, kunt u de cURL-bibliotheek van PHP gebruiken. Hier is hoe u de code kunt structureren:

<?php
// API endpoint URL
$url = 'http://127.0.0.1:1234/v1/chat/completions';

// Data to be sent in the POST request
$data = [
    'model' => 'llama-3.2-1b-instruct',
    'messages' => [
        ['role' => 'user', 'content' => 'Wat is de hoofdstad van Frankrijk?']
    ]
];

// Initialize cURL session
$ch = curl_init($url);

// Encode data to JSON format
$payload = json_encode($data);

// Set cURL options
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Content-Length: ' . strlen($payload)
]);

// Execute cURL request
$response = curl_exec($ch);

// Check for errors
if ($response === false) {
    $error = curl_error($ch);
    curl_close($ch);
    die('cURL Error: ' . $error);
}

// Close cURL session
curl_close($ch);

// Decode and display the response
$result = json_decode($response, true);
print_r($result);
?>

Dit stuurt een vraag naar het lokale LLM en print het antwoord.

7. Minimum systeemvereisten voor LM Studio

Wilt u een lokale LLM draaien? Dit zijn de minimale en aanbevolen specificaties:

Hoe krachtiger uw CPU/GPU, hoe sneller de LLM zal reageren. Een GPU zoals een NVIDIA RTX 3060+ kan het proces flink versnellen.

Conclusie

Met LM Studio kunt u lokale AI-modellen draaien, testen en gebruiken zonder afhankelijk te zijn van cloud-diensten. Of u nu een chatbot, AI-assistent of embedded LLM wilt maken, dit is een geweldige manier om AI lokaal te draaien.

Het bericht Hoe installeert u een lokale LLM op Ubuntu 24.10 met LM Studio? verscheen eerst op Utilewebsites.

Veelvoorkomende Zorgen van Ontwikkelaars

1. Betrouwbaarheid van AI-Gegenereerde Code: Ontwikkelaars vragen zich af hoe betrouwbaar de code is die door AI wordt gegenereerd. Er is een risico dat deze code minder geoptimaliseerd of veilig is dan handgeschreven code, wat extra werk kan vereisen om fouten te corrigeren.
2. Banenverlies door Automatisering: Een andere zorg is dat AI-tools, door repetitieve taken te automatiseren, bepaalde banen in de softwareontwikkeling zouden kunnen vervangen, wat vragen oproept over de toekomstige rol van menselijke ontwikkelaars.
3. Ethische Implicaties: Ontwikkelaars maken zich zorgen over de ethische implicaties van AI, zoals bias in AI-modellen en de mogelijkheid dat AI onbedoeld discriminerende algoritmen creëert.
4. Intellectueel Eigendom en Juridische Kwesties: Er is onzekerheid over wie de eigenaar is van door AI gegenereerde code en wat de juridische implicaties zijn als deze code gebaseerd blijkt te zijn op bestaande, mogelijk auteursrechtelijk beschermde code.
5. Afhankelijkheid van AI: Er is ook bezorgdheid dat teams te afhankelijk kunnen worden van AI-tools, waardoor essentiële programmeervaardigheden verloren kunnen gaan en de mogelijkheid om zonder AI te werken, wordt beperkt.

Waarom de Voordelen Zwaarder Kunnen Wegen

1. Verhoogde Productiviteit: AI-tools zoals GitHub Copilot kunnen ontwikkelaars aanzienlijk helpen bij het schrijven van code, het vinden van fouten, en het versnellen van repetitieve taken. Dit betekent dat ontwikkelteams sneller producten kunnen leveren en zich kunnen concentreren op meer complexe problemen die creatief en strategisch denken vereisen.
2. Minimalisatie van Risico's: Bedrijven kunnen gevoelige informatie zoals API-sleutels, wachtwoorden, en andere beveiligingsgerelateerde code eenvoudig buiten AI-tools houden. Door strikte richtlijnen en best practices te volgen, zoals het gebruik van environment variables voor gevoelige informatie, kunnen de risico's verder worden beperkt.
3. Mogelijkheid om AI Veilig te Integreren: Veel organisaties hebben al frameworks en processen ontwikkeld die AI veilig integreren in hun ontwikkelcyclus. Dit omvat het beperken van AI-toegang tot specifieke onderdelen van de codebase en het gebruiken van AI in sandboxed omgevingen, zodat gevoelige code en bedrijfsgeheimen niet in gevaar komen.
4. Concurrentievoordeel: Bedrijven die AI-tools efficiënt gebruiken, hebben vaak een concurrentievoordeel omdat ze sneller op de markt kunnen komen met nieuwe functies en producten. Dit kan cruciaal zijn in sectoren waar snelheid en innovatie van levensbelang zijn.

Wat Zegt OpenAI Hierover?

OpenAI stelt dat gegevens die via hun API worden verwerkt, niet worden gebruikt om het model verder te trainen zonder expliciete toestemming van de gebruiker. Dit biedt een zekere mate van bescherming voor bedrijven die gevoelige code willen delen via tools zoals GPT-4. Voor meer informatie hierover kun je de officiële documentatie van OpenAI raadplegen.

Wat Zegt GitHub Copilot Hierover?

GitHub Copilot, beheerd door Microsoft, volgt een vergelijkbaar beleid waarbij geen specifieke stukjes code worden opgeslagen of gebruikt voor verdere training tenzij de gebruiker hiervoor toestemming geeft. Dit helpt bij het minimaliseren van het risico op het onbedoeld delen van vertrouwelijke informatie. Meer details hierover kun je vinden op de GitHub Copilot FAQ-pagina.

Is de Angst Terecht?

De angst is begrijpelijk, vooral voor bedrijven die met gevoelige of eigendomsgebonden code werken. Hoewel de kans klein is dat AI-tools zoals GPT-4 of Copilot vertrouwelijke code daadwerkelijk verspreiden, is het risico niet volledig uit te sluiten. Het is essentieel dat bedrijven de risico's goed afwegen en voorzorgsmaatregelen nemen om gevoelige informatie te beschermen.

Beperkingen van AI-Tools

AI-modellen in 2024 zoals GPT-4 en GitHub Copilot hebben beperkingen, zoals beperkte contextverwerking en het onvermogen om de volledige complexiteit van een softwareproject te begrijpen. Dit maakt ze minder geschikt om zonder menselijke supervisie een volledig softwarepakket te beheren.

Conclusie

Hoewel er risico's zijn verbonden aan het gebruik van AI in softwareontwikkeling, kunnen deze vaak worden beheerst door de juiste veiligheidsmaatregelen te nemen. De voordelen van verhoogde productiviteit en snellere ontwikkelcycli wegen vaak zwaarder dan de relatief kleine risico's, vooral wanneer gevoelige informatie zorgvuldig wordt behandeld. Hierdoor kan AI een waardevolle toevoeging zijn aan moderne softwareontwikkelingsprocessen.

Het bericht De Angst voor AI in Softwareontwikkeling: Risico’s van Codeverspreiding en Privacyverlies verscheen eerst op Utilewebsites.

Bron : https://github.com/techleadhd/chatgpt-retrieval

Stapsgewijze handleiding:

1. Installatie en configuratie: Begin met het installeren van de LangChain-bibliotheek door het uitvoeren van "pip install langchain" of "conda install langchain -c conda-forge" in uw terminal.
2. Importeren van bibliotheken: Importeer de benodigde bibliotheken in uw Python-script. Dit omvat "os", "sys", "openai" en verschillende modules van de LangChain-bibliotheek, zoals "RetrievalQA", "ChatOpenAI", "DirectoryLoader", "TextLoader", "OpenAIEmbeddings", "VectorstoreIndexCreator" en "Chroma".
3. Instellen van de API-sleutel: Stel uw OpenAI API-sleutel in door deze toe te wijzen aan de omgevingsvariabele "OPENAI_API_KEY". Vervang "constants.APIKEY" in het script door uw daadwerkelijke API-sleutel.
4. Laden en indexeren van gegevens: Definieer de bron van uw gegevens door een "TextLoader" of "DirectoryLoader" object te maken, afhankelijk van of u wilt werken met een enkel tekstbestand of een map met meerdere bestanden. Pas de loader dienovereenkomstig aan en geef het bestand of de map op.
5. Creëren van de index: Maak een index met behulp van "VectorstoreIndexCreator" door de loader door te geven als parameter. Als u de index wilt cachen en hergebruiken, stelt u "PERSIST" in op True en geeft u een persistente map op. Anders stelt u "PERSIST" in op False.
6. Initialiseren van de ChatGPT-LangChain Chain: Maak een instantie van een RetrievalQA-chain met behulp van "ChatOpenAI" als taalmodel (bijvoorbeeld model="gpt-3.5-turbo"). Specificeer de retriever als de eerder gemaakte index vector store met behulp van "as_retriever(search_kwargs={"k": 1})".
7. Uitvoeren van zoekopdrachten: Geef een zoekopdracht op als argument voor het script, die kan worden doorgegeven via de opdrachtregel. Bijvoorbeeld, voer het script uit met "python script.py "Wat is de hoofdstad van Frankrijk?"". Het script zal het antwoord van ChatGPT afdrukken op basis van de verstrekte zoekopdracht.

Conclusie: Door de stappen in dit artikel te volgen en gebruik te maken van het meegeleverde script, kunt u eenvoudig ChatGPT en LangChain integreren om vraag- en antwoordtaken en chatbot-functionaliteiten uit te voeren op uw eigen tekstbestanden. De LangChain-bibliotheek biedt aanvullende functionaliteiten en integraties, waardoor u verschillende toepassingen van grote taalmodellen in uw projecten kunt verkennen. Raadpleeg de LangChain-documentatie voor meer details en geavanceerd gebruik.

ChatGPT-script met LangChain-integratie

import os
import sys

import openai
from langchain.chains import RetrievalQA
from langchain.chat_models import ChatOpenAI
from langchain.document_loaders import DirectoryLoader, TextLoader
from langchain.embeddings import OpenAIEmbeddings
from langchain.indexes import VectorstoreIndexCreator
from langchain.llms import OpenAI
from langchain.vectorstores import Chroma

import constants

os.environ["OPENAI_API_KEY"] = constants.APIKEY

# Inschakelen om het model op schijf te cachen en opnieuw te gebruiken (voor herhaalde zoekopdrachten op dezelfde gegevens)
PERSIST = False

query = sys.argv[1]

if PERSIST and os.path.exists("persist"):
  print("Index wordt opnieuw gebruikt...\n")
  vectorstore = Chroma(persist_directory="persist", embedding_function=OpenAIEmbeddings())
  from langchain.indexes.vectorstore import VectorStoreIndexWrapper
  index = VectorStoreIndexWrapper(vectorstore=vectorstore)
else:
  loader = TextLoader('data.txt')
  # Deze code kan ook mappen importeren, inclusief verschillende bestandstypen zoals PDF's, met behulp van de DirectoryLoader.
  # loader = DirectoryLoader(".", glob="*.txt")
  if PERSIST:
    index = VectorstoreIndexCreator(vectorstore_kwargs={"persist_directory":"persist"}).from_loaders([loader])
  else:
    index = VectorstoreIndexCreator().from_loaders([loader])

chain = RetrievalQA.from_chain_type(
  llm=ChatOpenAI(model="gpt-3.5-turbo"),
  retriever=index.vectorstore.as_retriever(search_kwargs={"k": 1}),
)
print(chain.run(query))

Het bericht Eenvoudig script om ChatGPT te gebruiken op uw eigen bestanden met LangChain verscheen eerst op Utilewebsites.