Tutorial RAG-Anything: Crea una pipeline di recupero multimodale per testo, tabelle, equazioni e immagini in Colab

Artificial Intelligence

Applicazioni

Tecnologia

Editori Consigliati

Modello di linguaggio

RAG

Piattaforma

Tutorial

Nel tutorial seguente, creiamo una workflow di RAG-Anything ed esploriamo come funziona il recupero multimodale attraverso testo, tabelle, equazioni e immagini. Iniziamo preparando l'ambiente Colab, installando i pacchetti necessari e inserendo il nostro API key di OpenAI in modo sicuro per rendere il notebook pratico ed eseguibile in modo sicuro. Successivamente creiamo un report multimodale sintetico, generiamo un grafico e un PDF, convertiamo il contenuto nel formato content_list di RAG-Anything e lo integreremo nel sistema di recupero. Mentre procediamo con il tutorial, configureremo funzioni di chat, visione e embedding di base OpenAI, inizializzeremo RAG-Anything e testeremo diverse modalità di recupero come naive, locale, globale ed ibrida.

Installazione delle dipendenze RAG-Anything

Per configurare l'ambiente di lavoro, installiamo RAG-Anything e la serie estesa di librerie di cui avremo bisogno nel corso del tutorial. Seguiamo questa procedura in base al codice seguente:

```python

import os

import re

import sys

import json

import time

import shutil

import hashlib

import asyncio

import inspect

import getpass

import subprocess

import importlib

import importlib.metadata

from pathlib import Path

from typing import List, Dict, Any

def run_shell(cmd, check=True):

print(f'\n$ {cmd}')

result = subprocess.run(cmd, shell=True, text=True)

if check and result.returncode != 0:

raise RuntimeError(f'Comando fallito: {cmd}')

return result.returncode

print("=" * 80)

print("RAG-Anything Avanzato Colab Tutorial")

print("=" * 80)

print("\n[1/10] Installazione delle dipendenze...")

for module_name in list(sys.modules):

if modulename == "PIL" or modulename.startswith("PIL."):

del sys.modules[module_name]

run_shell(

'pip -q install -U '

'"raganything[image,text]" '

'"openai>=1.0.0" '

'"python-dotenv" '

'"reportlab" '

'"pandas" '

'"matplotlib" '

'"tabulate"'

)

run_shell('pip -q install --no-cache-dir --force-reinstall "pillow==11.3.0"')

for module_name in list(sys.modules):

if modulename == "PIL" or modulename.startswith("PIL."):

del sys.modules[module_name]

importlib.invalidate_caches()

try:

print("Versione Pillow:", importlib.metadata.version("Pillow"))

except Exception as e:

print("Impossibile leggere la versione di Pillow:", repr(e))

print("\n[2/10] Importing librerie...")

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

from IPython.display import display

from reportlab.lib.pagesizes import letter

from reportlab.pdfgen import canvas

from reportlab.lib.units import inch

from openai import AsyncOpenAI

from raganything import RAGAnything, RAGAnythingConfig

from lightrag.utils import EmbeddingFunc

print("Import completata.")

```

Instaurare configurazioni, directory e variabili di esecuzione

Successivamente, prepariamo directory e variabili di esecuzione che RAG-Anything utilizzerà durante l’esecuzione del notebook. Seguiamo questa procedura:

```python

print("\n[3/10] Preparazione delle directory e delle impostazioni di esecuzione...")

BASEDIR = Path("/content/raganythingadvancedtutorial") if Path("/content").exists() else Path.cwd() / "raganythingadvanced_tutorial"

ASSETDIR = BASEDIR / "assets"

OUTPUTDIR = BASEDIR / "output"

WORKINGDIR = BASEDIR / "rag_storage"

LOGDIR = BASEDIR / "logs"

RESET_STORAGE = True

RUNFULLDOCUMENT_PARSE = False

PARSERFORFULL_PARSE = "mineru"

PARSE_METHOD = "auto"

for d in [BASEDIR, ASSETDIR, OUTPUTDIR, WORKINGDIR, LOG_DIR]:

d.mkdir(parents=True, exist_ok=True)

if RESETSTORAGE and WORKINGDIR.exists():

shutil.rmtree(WORKING_DIR)

WORKINGDIR.mkdir(parents=True, existok=True)

os.environ["LOGDIR"] = str(LOGDIR)

os.environ["SUMMARY_LANGUAGE"] = "English"

os.environ["ENABLELLMCACHE"] = "false"

os.environ["ENABLELLMCACHEFOREXTRACT"] = "false"

os.environ["MAX_ASYNC"] = "2"

os.environ["CHUNK_SIZE"] = "900"

os.environ["CHUNKOVERLAPSIZE"] = "120"

os.environ["TIMEOUT"] = "240"

for var in [

"OPENAIAPIKEY",

"OPENAIORGID",

"OPENAI_ORGANIZATION",

"OPENAI_PROJECT",

"OPENAIDEFAULTHEADERS",

"LLMBINDINGAPI_KEY",

"LLMBINDINGHOST",

]:

os.environ.pop(var, None)

print(f"Directory principale: {BASE_DIR}")

print(f"Directory assets: {ASSET_DIR}")

print(f"Directory storage: {WORKING_DIR}")

print("\n[4/10] Inserire in modo sicuro la chiave API di OpenAI...")

def cleanapikey(raw_value: str) -> str:

rawvalue = str(rawvalue or "").strip()

rawvalue = rawvalue.replace("Bearer ", "").replace("bearer ", "").strip()

rawvalue = rawvalue.strip("'").strip('"').strip("`").strip()

if "=" in raw_value:

rawvalue = rawvalue.split("=", 1)[1].strip().strip("'").strip('"').strip("`")

rawvalue = re.sub(r"\s+", "", rawvalue)

rawvalue = rawvalue.encode("ascii", errors="ignore").decode("ascii").strip()

return raw_value

OPENAIAPIKEY_RAW = getpass.getpass("Incolla qui la tua chiave API di OpenAI. L'input è nascosto: ")

OPENAIAPIKEY = cleanapikey(OPENAIAPIKEY_RAW)

if not OPENAIAPIKEY:

raise ValueError(

"Non è stata catturata alcuna chiave API. Incolla la chiave nel campo d'input nascosto e premi Invio."

)

print("Lunghezza chiave catturata:", len(OPENAIAPIKEY))

print("Prefisso chiave catturata:", OPENAIAPIKEY[:12] + "...")

print("Suffisso chiave catturata:", "..." + OPENAIAPIKEY[-6:])

LLM_MODEL = "gpt-4o-mini"

VISION_MODEL = "gpt-4o-mini"

EMBEDDING_MODEL = "text-embedding-3-small"

EMBEDDING_DIM = 1536

openaiclient = AsyncOpenAI(apikey=OPENAIAPIKEY)

os.environ["LLMMODEL"] = LLMMODEL

os.environ["VISIONMODEL"] = VISIONMODEL

os.environ["EMBEDDINGMODEL"] = EMBEDDINGMODEL

os.environ["EMBEDDINGDIM"] = str(EMBEDDINGDIM)

print("Test API chat OpenAI con la chiave catturata...")

try:

testresponse = await openaiclient.chat.completions.create(

model=LLM_MODEL,

messages=[{"role": "user", "content": "Rispondi con esattamente: ok"}],

temperature=0,

)

print("Risposta API chat:", test_response.choices[0].message.content)

except Exception as e:

raise RuntimeError(

"La chiave è stata catturata, ma OpenAI ha rifiutato la richiesta o l'accesso al modello è fallito. Controlla il conto, le autorizzazioni del progetto e conferma che sia una chiave API OpenAI Platform."

) from e

print("\nTest API embeddings OpenAI...")

try:

testembedding = await openaiclient.embeddings.create(

model=EMBEDDING_MODEL,

input=["Test embedding RAG-Anything"],

)

print("Lunghezza vettore embedding:", len