1. Video Generation Models

Wan 2.1 / 2.2

• Description: The current standard for open-source video. Highly stable in motion and anatomy.
• Use case: High-end cinematography, realistic human actions.
• GitHub (Model): Wan-Video/Wan2.1
• ComfyUI Node: kijai/ComfyUI-WanVideoWrapper

Hunyuan Video (v1.5)

• Description: Tencent's flagship model with 13 billion parameters, now in v1.5 with improved prompt adherence and a "distilled" version for speed.
• Use case: Complex textual instructions and long scenes.
• GitHub (Model): Tencent-Hunyuan/HunyuanVideo
• ComfyUI Node: kijai/ComfyUI-HunyuanVideoWrapper

LTX Video (LTXV)

• Description: A DiT-based model focused on real-time generation and efficiency on consumer GPUs.
• Use case: Fast previews and real-time video-to-video transformations.
• GitHub (Model): Lightricks/LTX-Video
• ComfyUI Node: Lightricks/ComfyUI-LTXVideo

Kandinsky 5.0 Video (Lite & Pro)

• Description: A suite of models based on the Cross-Attention Diffusion Transformer (CrossDiT). The Lite (2B) version is lightning fast and runs on consumer GPUs, while the Pro (19B) version generates cinematic 10-second clips with complex camera movements.
• Use case: Versatile video creation (Text-to-Video and Image-to-Video) with strong support for various languages and artistic styles.
• GitHub (Model): kandinskylab/kandinsky-5
• ComfyUI Template: Kandinsky 5 Video Workflow (Official)

Specialized Video Fine-tunes

• SCAIL: Studio-grade character animation (pose-to-video) with 3D consistency.
  • GitHub: zai-org/SCAIL | ComfyUI: ComfyUI-SCAIL-Pose (part of WanVideoWrapper).
• MoCha: The standard for seamlessly replacing characters in existing videos.
  • GitHub: Orange-3DV-Team/MoCha | ComfyUI: Integrated into WanVideoWrapper.
• Nexus 1.3B : Description: A specialized fine-tune of the Wan 1.3B architecture, developed within the Nexus project. This model is specifically trained on "Nexus data" for complex human movements. Use case: Dance, martial arts, and gym exercises where anatomical correctness is crucial. GitHub (Model): PKU-YuanGroup/OpenS2V-Nexus ComfyUI Node: Supported via the WanVideoWrapper.

2. Image Generation Models

FLUX.2

• Description: The successor to FLUX.1. Offers photorealism and text rendering that rivals commercial models like Midjourney.
• Use case: Everything from marketing materials to complex digital art.
• GitHub (Model): black-forest-labs/flux2
• ComfyUI Node: city96/ComfyUI-GGUF (for GGUF quantizations).

Qwen Image 2512

• Description: An advanced model from Alibaba that excels in following instructions for image editing.
• Use case: Layer-based editing and complex compositions.
• GitHub (Model): QwenLM/Qwen-Image
• ComfyUI Node: Use the ComfyUI-Manager and search for "Qwen2-VL".

Z-Image (Turbo)

• Description: A 6B parameter model from Alibaba that delivers top-tier results in just 8 steps.
• Use case: Real-time generation and systems with limited hardware.
• GitHub (Model): Tongyi-MAI/Z-Image
• ComfyUI Node: Integrated via WanVideoWrapper or directly via diffusers.

Het bericht Overview Map: Open-Source AI Video & Image Models (January 2026) verscheen eerst op Utilewebsites.

What is ComfyUI?

ComfyUI is a powerful and modular visual AI engine that works with stable diffusion workflows. Instead of a closed interface, you get a graph- and node-based canvas. With this, you can build your own AI pipelines by connecting, branching, and adjusting nodes. This gives you maximum freedom to create exactly the workflow you need.

Test the latest models yourself

Because AI models evolve so quickly, you will of course want to try them out right away. If you have a PC with sufficient hardware — for example an NVIDIA RTX graphics card with at least 8GB of VRAM — you can install ComfyUI locally. This allows you to run the latest models directly on your own system, without queues or per-prompt costs.

Save, share, and reuse workflows

What makes ComfyUI especially powerful is that you can not only create workflows, but also easily save and share them. Files such as images, videos, or 3D models contain metadata that allows the full workflow to be automatically rebuilt as soon as you drop them into ComfyUI. This is ideal for collaboration, learning from others, or simply experimenting again quickly.

Open-source and cross-platform

ComfyUI is completely free and open-source, and available for Windows, Linux, and macOS. Whether you are a creative maker who wants to experiment visually, or a developer who wants to dive deeper technically: the tool adapts to your workflow.

Why choose ComfyUI?

• Flexible and modular: build your own AI workflows.
• Future-proof: easily test the latest models.
• Run locally: no cloud costs or dependencies.
• Community-driven: share, remix, and reuse workflows.

In short: if you want to truly take control of AI creation, and explore all the new models that appear every week, then ComfyUI is the engine to get started with.

Download ComfyUI from the official website: https://www.comfy.org/

Het bericht Discover ComfyUI: the modular visual AI engine for creative workflows verscheen eerst op Utilewebsites.

Want to experiment with Large Language Models (LLMs) without relying on cloud services? With Ollama you can run powerful open-source language models directly on your own computer. This not only guarantees your privacy, but also gives you full control over your data and the models you use. In this article we explain step by step how to install Ollama, use an LLM locally, and how to integrate it with popular developer tools such as LangChain and Visual Studio Code.

What is Ollama?

Ollama is a tool that greatly simplifies the process of downloading, setting up, and running LLMs, such as Llama 3. It packages model weights and configurations into a single file, similar to how Docker works for applications. This makes it easy for both developers and enthusiasts to get started with LLMs.

System Requirements

Before you begin, it's important to check that your system meets the minimum requirements. To run smaller models (around 7 billion parameters), the following is recommended:

• RAM: At least 8 GB, but 16 GB is recommended for better performance.
• Storage: Sufficient free disk space for the models, which can be several gigabytes in size.

For larger models, you'll need significantly more RAM and possibly a powerful graphics card (GPU).

Installation

Ollama is available for Windows, macOS and Linux.

1. Download Ollama: Go to the official Ollama website at https://ollama.com/ and download the installer for your operating system.
2. Install Ollama: Run the downloaded file and follow the installation instructions. After installation, Ollama runs in the background.

Downloading and Running a Model

1. Open the terminal:
   • Windows: Open the Start menu, type cmd or Terminal, and press Enter.
   • macOS: Open the Terminal app from the Utilities folder.
   • Linux: Open your preferred terminal emulator.
2. Download a model: Choose a model from the Ollama library (found at https://ollama.com/library). A popular and powerful model to start with is Llama 3.1. Download it with the following command:

ollama pull llama3.1

This may take a while, depending on the size of the model and your internet speed.

3. Run the model: Once the download is complete, you can use the model directly in your terminal with the following command:

ollama run llama3.1

Interaction and Useful Commands

After running the run command, you can immediately start asking questions or giving commands to the model. You essentially chat with the LLM in your terminal.

• ollama list: Shows a list of all models you have downloaded locally.
• ollama rm <model-name>: Removes a specific model to free up disk space.
• /bye: Closes the current chat session with a model.

Integration with LangChain

LangChain is a popular framework for building applications with LLMs. You can easily integrate your locally running Ollama model into both Python and JavaScript/TypeScript projects.

Python

1. Install the Python package:

pip install langchain-ollama

2. Use in your code:

from langchain_ollama import ChatOllama

llm = ChatOllama(model="llama3.1")
response = llm.invoke("What is the capital of the Netherlands?")
print(response.content)

Node.js (JavaScript/TypeScript)

LangChain is also available for JavaScript/TypeScript, ideal for back-ends (Node.js) or front-end frameworks (such as Vue.js, React or Svelte).

1. Install via npm or yarn:

# For npm
npm install @langchain/ollama

# For yarn
yarn add @langchain/ollama

2. Use in your code:

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

async function main() {
  const llm = new ChatOllama({ model: "llama3.1" });
  const response = await llm.invoke("What is the capital of the Netherlands?");
  console.log(response.content);
}

main();

This way, you can seamlessly switch between cloud providers and your own local Ollama instance in both your Python backend and your JavaScript stack.

Integration with Visual Studio Code

You can also use your locally running LLM as a complement to your development environment in Visual Studio Code. This gives you the ability to generate code and ask questions using your own, locally hosted model.

1. Ensure Ollama is running: The Ollama process must be active in the background.
2. Install a compatible extension: Search the VS Code Marketplace for an extension that offers Ollama integration, such as Continue.
3. Configure the extension: Follow the extension's instructions to set Ollama as the provider and select the model you want to use (for example llama3.1).

Now you can call your local model for code suggestions and other programming tasks in the extension's chat interface, entirely within your own environment.

Conclusion

Ollama makes running LLMs locally accessible to a wide audience. Whether you're a developer looking to build an AI application with LangChain, or want to improve your programming workflow in VS Code, Ollama lets you get started quickly and easily. With an active community and ongoing development, Ollama is an excellent choice for anyone looking to explore the world of local AI.

Het bericht Run a Large Language Model (LLM) locally with Ollama verscheen eerst op Utilewebsites.

With LM Studio, you can run local AI models (LLMs) on your own computer, without relying on cloud services like OpenAI. In this guide, you'll learn how to install LM Studio, download an LLM, test it, and how to start the API server to use the model in your own applications.

1. Download and Install LM Studio

LM Studio is distributed as an AppImage, a standalone executable file. Follow these steps to install it:

1. Download LM Studio
   • Go to lmstudio.ai and download the Linux AppImage.
   • Save the file in a directory such as ~/Applications/.
2. Make the file executable
   Open a terminal and run the following command: chmod +x ~/Applications/LM-Studio-*.AppImage
3. Start LM Studio ~/Applications/LM-Studio-*.AppImage You can now use LM Studio, but let's also ensure it appears in your application menu.

2. Add LM Studio to the Applications Menu

Create a .desktop file so that LM Studio appears in your application menu:

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

Paste this content and adjust the path:

[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;

Save with CTRL+O, close with CTRL+X, and update the menu:

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

You can now open LM Studio from the application menu!

3. Download a Local LLM Model

1. Open LM Studio and go to Model Search.
2. Search for Llama 3.2 1B Instruct (lightweight and beginner-friendly).
3. Select a Q4_K_M or Q8_0 quantization (lower bit values use less RAM).
4. Wait for the download to complete.

4. Test if the Model Works

• Go to Chats in LM Studio.
• Start a new chat and select the loaded model.
• Type questions like: "What is the capital of France?" "Explain quantum mechanics in simple terms." "What is LLM model Llama-3.3-1B?"
• If the model responds, everything is working!

5. Start the LLM API Server for Use in Your Own App

Want to integrate LM Studio into your Python app or chatbot? Start the local server:

1. Open LM Studio and enable "Developer mode".
2. Click "Start Server" (the server will run at http://127.0.0.1:1234).
3. Test if it's working: curl http://127.0.0.1:1234/v1/models

6. Example: Using LLM in a Python App

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": "What is the capital of France?"}]
}

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

To send a JSON-formatted POST request in PHP to interact with LM Studio's API, you can utilize PHP's cURL library. Here's how you can structure your code:

<?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);
?>

This sends a query to the local LLM and prints the response.

7. Minimum System Requirements for LM Studio

Want to run a local LLM? Here are the minimum and recommended specifications:

The more powerful your CPU/GPU, the faster the LLM will respond. A GPU like an NVIDIA RTX 3060+ can significantly speed up the process.

Conclusion

With LM Studio, you can run, test, and use local AI models without depending on cloud services. Whether you're creating a chatbot, AI assistant, or embedded LLM, this is a great way to run AI locally.

Het bericht How to Install a Local LLM on Ubuntu 24.10 with LM Studio? verscheen eerst op Utilewebsites.

Common Concerns of Developers

1. Reliability of AI-Generated Code: Developers worry about the reliability of code generated by AI. There is a risk that this code may be less optimized or secure than handwritten code, which might require additional work to correct errors.
2. Job Loss Due to Automation: Another concern is that AI tools, by automating repetitive tasks, could replace certain jobs in software development, raising questions about the future role of human developers.
3. Ethical Implications: Developers are concerned about the ethical implications of AI, such as bias in AI models and the possibility of AI unintentionally creating discriminatory algorithms.
4. Intellectual Property and Legal Issues: There is uncertainty about who owns AI-generated code and what the legal implications are if this code turns out to be based on existing, potentially copyrighted code.
5. Dependence on AI: There is also concern that teams might become too dependent on AI tools, leading to a loss of essential programming skills and the ability to work without AI.

Why the Benefits Might Outweigh the Risks

1. Increased Productivity: AI tools like GitHub Copilot can significantly assist developers in writing code, finding errors, and speeding up repetitive tasks. This means development teams can deliver products faster and focus on more complex problems that require creative and strategic thinking.
2. Minimizing Risks: Companies can easily keep sensitive information like API keys, passwords, and other security-related code outside of AI tools. By following strict guidelines and best practices, such as using environment variables for sensitive information, risks can be further minimized.
3. Safe AI Integration: Many organizations have already developed frameworks and processes that safely integrate AI into their development cycle. This includes limiting AI access to specific parts of the codebase and using AI in sandboxed environments to ensure that sensitive code and trade secrets are not compromised.
4. Competitive Advantage: Companies that use AI tools efficiently often have a competitive advantage because they can bring new features and products to market faster. This can be crucial in sectors where speed and innovation are essential.

What Does OpenAI Say About This?

OpenAI states that data processed through their API is not used to further train the model without the user's explicit consent. This provides a level of protection for companies that want to share sensitive code via tools like GPT-4. For more information, you can refer to OpenAI's official documentation.

What Does GitHub Copilot Say About This?

GitHub Copilot, managed by Microsoft, follows a similar policy where no specific pieces of code are stored or used for further training unless the user gives explicit permission. This helps minimize the risk of unintentionally sharing confidential information. More details about this can be found on the GitHub Copilot FAQ page.

Is the Fear Justified?

The fear is understandable, especially for companies working with sensitive or proprietary code. While the likelihood that AI tools like GPT-4 or Copilot will actually leak or reuse confidential code is small, the risk cannot be entirely dismissed. It is essential that companies carefully weigh these risks and take precautions to protect sensitive information.

Limitations of AI Tools

AI models in 2024 like GPT-4 and GitHub Copilot have limitations, such as limited context processing and an inability to understand the full complexity of a software project. This makes them less suitable for managing a complete software package without human supervision.

Conclusion

While there are risks associated with using AI in software development, these can often be mitigated by taking the right safety measures. The benefits of increased productivity and faster development cycles often outweigh the relatively small risks, especially when sensitive information is handled with care. This makes AI a valuable addition to modern software development processes.

Het bericht The Fear of AI in Software Development: Risks of Code Leakage and Privacy Loss verscheen eerst op Utilewebsites.

Django is one of the most popular web frameworks for building modern, scalable web applications. Debian 10, known for its stability and security, offers a solid foundation for hosting. When combined with Apache, one of the most widely-used web servers, and WSGI to bridge the gap between Python applications and web servers, you get a robust and reliable stack for your web projects.

Whether you are an experienced Django developer seeking a reliable way to host your application or a beginner just starting with Django and in search of a clear and concise guide, this tutorial will walk you through the entire process.

Read on for detailed instructions, including the configuration of virtual hosts, directory permissions, and more. Learn how to install and configure your Django application on a Debian 10 system running Apache and WSGI, and get your project online today!

Step 1: Preparation of the system

Make sure your Debian 10 system is up to date:

sudo apt update
sudo apt upgrade

Step 2: Installation of Apache and required modules

Install Apache and the mod_wsgi module:

sudo apt install apache2
sudo apt install libapache2-mod-wsgi-py3
sudo a2enmod wsgi

Step 3: Installation of Python 3.7

Check your current Python version:

python3 --version

If necessary, install Python 3.7:

sudo apt install python3.7

Step 4: Creating and setting up a virtual environment

Install and create packages for a virtual environment:

sudo apt install python3-venv
python3 -m venv /var/www/djangoapplicatie.nl/web/srv/webapps/pythoneditortool/myenv

Step 5: Installation of Django

Activate the virtual environment and install Django:

source /var/www/djangoapplicatie.nl/web/srv/webapps/pythoneditortool/myenv/bin/activate
pip3 install django

Step 6: Virtual Host Configuration (vhost).

1. Directory Permissions.

Configure access rights:

<Directory /var/www/djangoapplicatie.nl>
 <IfVersion < 2.3 >
   Order allow,deny
   Allow from all
 </IfVersion>
 <IfVersion >= 2.3>
   Require all granted
 </IfVersion>
</Directory>

2. Virtual Host Block

Define the beginning of the configuration block:

<VirtualHost *:80>
...
</VirtualHost>

3. DocumentRoot, ServerName, and ServerAlias.

Set paths, domain name, and aliases:

DocumentRoot /var/www/djangoapplicatie.nl/web/srv/webapps/pythoneditortool/src
ServerName djangoapplicatie.nl
ServerAlias www.djangoapplicatie.nl

4. ErrorLog and CustomLog

Define log locations:

ErrorLog ${APACHE_LOG_DIR}/djangoapplicatie.nl.error.log
CustomLog ${APACHE_LOG_DIR}/djangoapplicatie.nl.access.log combined

5. Static and Media Aliases

Make static and media files accessible.

6. WSGI Configuration

Connect the Django application to Apache via WSGI:

WSGIDaemonProcess pythoneditortool python-path=/var/www/djangoapplicatie.nl/web/srv/webapps/pythoneditortool/src python-home=/var/www/djangoapplicatie.nl/web/srv/webapps/pythoneditortool/myenv
WSGIProcessGroup pythoneditortool
WSGIScriptAlias / /var/www/djangoapplicatie.nl/web/srv/webapps/pythoneditortool/src/wsgi.py

7. PHP-FPM and Suexec Configuration.

Configure PHP scripts and user rights.

8. DAV Configuration

Set up WebDAV.

Save file and restart Apache

Save, enable, and restart Apache:

sudo a2ensite djangoapplicatie.nl.conf
sudo systemctl restart apache2

Example entire vhost file

<VirtualHost *:80>
    ServerAdmin webmaster@djangoapplicatie.nl
    DocumentRoot /var/www/djangoapplicatie.nl/web/srv/webapps/pythoneditortool/src
    ServerName djangoapplicatie.nl
    ServerAlias www.djangoapplicatie.nl

    <Directory /var/www/djangoapplicatie.nl>
        <IfVersion < 2.3 >
            Order allow,deny
            Allow from all
        </IfVersion>
        <IfVersion >= 2.3>
            Require all granted
        </IfVersion>
    </Directory>

    Alias /static/ /var/www/djangoapplicatie.nl/static/
    Alias /media/ /var/www/djangoapplicatie.nl/media/

    <Directory /var/www/djangoapplicatie.nl/static>
        Require all granted
    </Directory>

    <Directory /var/www/djangoapplicatie.nl/media>
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/djangoapplicatie.nl.error.log
    CustomLog ${APACHE_LOG_DIR}/djangoapplicatie.nl.access.log combined

    WSGIDaemonProcess pythoneditortool python-path=/var/www/djangoapplicatie.nl/web/srv/webapps/pythoneditortool/src python-home=/var/www/djangoapplicatie.nl/web/srv/webapps/pythoneditortool/myenv
    WSGIProcessGroup pythoneditortool
    WSGIScriptAlias / /var/www/djangoapplicatie.nl/web/srv/webapps/pythoneditortool/src/wsgi.py

    # Suexec en PHP-FPM (if needed)
    # ...

    # DAV Configuration (if needed)
    # ...
</VirtualHost>

Step 7: Check your installation

Open your domain to check that everything is working.

Conclusion

Setting up a Django application with Apache on Debian 10 requires a few steps, including installing Apache, Python, and the necessary modules, setting up a virtual environment, and configuring a virtual host in Apache. Your configuration file serves as an excellent example of the proper settings. If everything is configured correctly, your Django application should now be reachable through your domain.

Learn more: Setting Up Django Application From Scratch

If you are just starting out with Django and want to build an application from scratch, you can benefit from the extensive and detailed documentation provided by the Django project itself.

The officialDjango documentation provides a tutorial series that guides you in creating a Django application from scratch. From installing Django to defining models, creating views and customizing templates, these tutorials provide detailed explanations and code examples to help you successfully build your first Django application.

Suitable for developers of all levels, the tutorial is an excellent resource to familiarize you with key concepts and practices within Django. Whether you are a complete beginner or want to refresh your knowledge, the manual provides practical instructions and best practices straight from the experts behind Django itself.

Get started now with the official Django Tutorial

Het bericht Complete Guide to Installing a Django Application on Debian 10 with Apache and WSGI: Step-by-Step Guide verscheen eerst op Utilewebsites.

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

Step-by-step guide:

1. Installation and configuration: Start by installing the LangChain library by running "pip install langchain" or "conda install langchain -c conda-forge" in your terminal.
2. Importing libraries: Import the required libraries into your Python script. This includes "os", "sys", "openai" and several modules of the LangChain library, such as "RetrievalQA", "ChatOpenAI", "DirectoryLoader", "TextLoader", "OpenAIEmbeddings", "VectorstoreIndexCreator" and "Chroma".
3. Setting the API key: Set your OpenAI API key by assigning it to the environment variable "OPENAI_API_KEY". Replace "constants.APIKEY" in the script with your actual API key.
4. Loading and indexing data: Define the source of your data by creating a "TextLoader" or "DirectoryLoader" object, depending on whether you want to work with a single text file or a directory with multiple files. Adjust the loader accordingly and specify the file or folder.
5. Creating the index: Create an index using "VectorstoreIndexCreator" by passing the loader as a parameter. If you want to cache and reuse the index, set "PERSIST" to True and specify a persistent directory. Otherwise, set "PERSIST" to False.
6. Initializing the ChatGPT-LangChain Chain: Create an instance of a RetrievalQA-chain using "ChatOpenAI" as the language model (for example, model="gpt-3.5-turbo"). Specify the retriever as the previously created index vector store using "as_retriever(search_kwargs={"k": 1})".
7. Run searches: Specify a query as an argument to the script, which can be passed through the command line. For example, run the script with "python script.py "What is the capital of France?"". The script will print ChatGPT's response based on the query provided.

Conclusion: By following the steps outlined in this article and utilizing the provided script, you can easily incorporate ChatGPT and LangChain to perform question answering and chatbot tasks on your own text files. The LangChain library offers additional functionalities and integrations, allowing you to explore various applications of large language models in your projects. Refer to the LangChain documentation for more details and advanced usage.

ChatGPT script with LangChain integration

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

# Enable to cache & reuse the model to disk (for repeated queries on the same data)
PERSIST = False

query = sys.argv[1]

if PERSIST and os.path.exists("persist"):
  print("Reusing index...\n")
  vectorstore = Chroma(persist_directory="persist", embedding_function=OpenAIEmbeddings())
  from langchain.indexes.vectorstore import VectorStoreIndexWrapper
  index = VectorStoreIndexWrapper(vectorstore=vectorstore)
else:
  loader = TextLoader('data.txt')
  # This code can also import folders, including various filetypes like PDFs using the 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 Simple script to use ChatGPT on your own files with LangChain verscheen eerst op Utilewebsites.