Note :

Intégrez LangChain, carnet du service de science des données pour OCI, OCI à OpenSearch et à l'intelligence artificielle générative pour OCI afin d'accélérer le développement LLM pour la recherche RAG et conversationnelle

Présentation

Dans ce tutoriel, nous explorerons comment LangChain, le carnet du service de science des données pour Oracle Cloud Infrastructure (OCI), OCI avec OpenSearch, les actions rapides d'IA du service de science des données pour OCI et le service d'IA générative pour OCI s'intègrent de façon transparente afin de simplifier le développement d'applications de modèles de langage volumineux (LLM). Ces outils accélèrent les flux de travail, améliorent la productivité et permettent un déploiement plus rapide de solutions d'IA de pointe adaptées aux besoins d'affaires spécifiques.

Dans le premier tutoriel : Tutoriel 1 : Intégrer la recherche OCI à OpenSearch et LangChain dans le carnet du service de science des données OCI, nous avons discuté de l'impact transformateur de l'intégration de LangChain, d'OCI à OpenSearch et de Hugging Face, démontrant comment ces technologies peuvent fonctionner avec le carnet du service de science des données OCI pour simplifier le développement et la production de solutions de recherche sémantique pour les entreprises. Nous avons détaillé les étapes de configuration de bout en bout pour configurer OCI avec OpenSearch, configurer le carnet du service de science des données pour OCI, configurer LangChain avec la session de carnet et déployer un cas d'utilisation complet pour la recherche sémantique.

S'appuyant sur cette base, ce tutoriel se concentre sur la façon dont l'intégration transparente entre LangChain, OCI avec OpenSearch, AI Quick Actions et OCI Generative AI peut accélérer le développement d'applications LLM pour des cas d'utilisation commerciale personnalisés. Nous aborderons en particulier les solutions de recherche conversationnelle, de génération augmentée par récupération (RAG) et d'agents conversationnels à réponse aux questions, montrant comment ces outils permettent aux développeurs de relever les défis et de fournir des applications innovantes et évolutives avec un minimum de codage.

Note : Vous trouverez des exemples de code complets pour ce tutoriel dans notre référentiel d'échantillons publics ici : Exemples de code de service OCI OpenSearch.

Avantages de l'approche intégrée

La création d'applications avec des LLM implique plusieurs étapes :

Chaque étape peut nécessiter des outils spécialisés, des pipelines complexes et des efforts de développement importants. En intégrant LangChain aux services OCI, les développeurs peuvent relever ces défis de manière holistique, ce qui réduit la complexité et améliore la productivité.

Objectifs

Préalables

Tâche 1 : Créer un projet du service de science des données pour OCI et configurer des carnets

Le carnet du service de science des données pour OCI offre une plateforme flexible et interactive pour développer, tester et déployer des applications d'IA. L'intégration de carnets aux services OCI crée une expérience de développement transparente, réduisant ainsi le besoin d'outils externes. Avec les carnets, vous pouvez :

Pour créer un projet du service de science des données pour OCI et configurer un carnet, voir Tâche 2 : Lancer un carnet Jupyter dans le service de science des données pour OCI.

Tâche 2 : Installer LangChain

LangChain est l'un des cadres les plus polyvalents pour le développement d'applications LLM. Sa conception modulaire et sa bibliothèque étendue fournissent des abstractions robustes pour :

La capacité de LangChain à s'interfacer de façon transparente avec des services en nuage comme l'IA générative OCI, OCI avec OpenSearch et le service de science des données OCI améliore son utilité pour créer des applications de niveau entreprise. La flexibilité de LangChain permet aux développeurs de prototyper et d'itérer rapidement les applications, ce qui le rend idéal pour les solutions de recherche RAG et conversationnelle. Ses intégrations aux services OCI simplifient davantage le processus de développement, permettant aux développeurs de se concentrer sur la création de valeur. Dans le premier tutoriel, nous avons décrit comment configurer LangChain avec un environnement de carnet. Nous avons présenté un exemple de bout en bout de l'utilisation de LangChain pour traiter des données non structurées, les ingérer dans OCI avec OpenSearch et effectuer une recherche sémantique. 

Exécutez la commande suivante dans votre carnet pour configurer LangChain et d'autres bibliothèques de clés.

!pip install -U oci oracle_ads langchain langchain-community  langchain-huggingface  opensearch-py pypdf

Tâche 3 : Utilisez LangChain pour pré-traiter et fragmenter vos données

Utilisez le code Python suivant.

import os
from langchain.document_loaders import PyPDFLoader, CSVLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
 
# Step 1: Load PDF and CSV Documents
def load_documents():
    # Load PDF Document
    pdf_loader = PyPDFLoader("data/sample_document.pdf")
    pdf_documents = pdf_loader.load()
 
    # Load CSV Document
    csv_loader = CSVLoader(file_path="data/sample_data.csv")
    csv_documents = csv_loader.load()
 
    # Combine both sets of documents
    all_documents = pdf_documents + csv_documents
    return all_documents
 
# Step 2: Split the documents into smaller chunks for better processing
def split_documents(documents):
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=100
    )
    split_docs = text_splitter.split_documents(documents)
    return split_docs
 
 
# Load and process documents
documents = load_documents()
split_docs = split_documents(documents)

Tâche 4 : Configurer le modèle d'intégration avec la cohère d'intelligence artificielle générative OCI

Le service d'IA générative OCI fournit une plate-forme entièrement gérée pour accéder à des LLM de pointe, tels que Cohere et Meta LLaMA-3. Il prend en charge les modèles suivants :

La principale différence entre les actions rapides d'IA et l'IA générative OCI est que les actions rapides d'IA disposent d'un catalogue de modèles plus complet et offrent beaucoup plus de flexibilité avec l'entraînement, l'évaluation, la mise au point et la gestion du cycle de vie des modèles. L'avantage majeur avec l'IA générative OCI est que vous n'avez pas à posséder l'infrastructure qui héberge votre modèle. Vous pouvez utiliser le point d'extrémité générique pour l'un des modèles disponibles et vous n'êtes facturé que selon le nombre de demandes et le nombre de jetons. En revanche, avec les actions rapides AI, bien que vous ayez plus d'autonomie sur votre LLM ou sur toute orchestration de flux de travail AI/ML et tout cycle de vie, vous ne payez que pour le coût de l'infra et vous avez des demandes illimitées. 

De plus, le service d'intelligence artificielle générative OCI est prêt à utiliser des modèles d'intégration d'entreprise tels que le modèle Cohere Embed V3, qui est conçu pour les données d'entreprise et est connu pour offrir une meilleure performance que les autres modèles de transformateur de phrase préentraînés à partir du visage d'étreinte, en particulier sur les données personnalisées. Il vous suffit d'appeler ce modèle pour générer l'intégration de vos données. Par conséquent, nous croyons que la combinaison de l'IA générative OCI et des actions rapides d'IA peut vous donner la meilleure valeur pour votre application d'affaires. Vous pouvez appeler le point d'extrémité de modèle d'intégration de cohère d'IA générative OCI déjà déployé pour intégrer vos données, et utiliser les actions rapides d'IA pour affiner, tester, évaluer et déployer votre modèle. 

LangChain s'intègre de façon transparente à l'intelligence artificielle générative et à l'action rapide de l'intelligence artificielle pour OCI, permettant aux développeurs d'appeler des modèles directement à partir de leur environnement OCI. Avec une configuration minimale, les développeurs peuvent commencer à utiliser des modèles préentraînés ou peaufinés.

Voici un exemple d'utilisation de l'intégration LangChain pour appeler le modèle V3 intégré de cohère et l'utiliser pour intégrer vos documents lors de l'ingestion de données.

from langchain_community.embeddings import OCIGenAIEmbeddings

oci_cohere_embedding_model = OCIGenAIEmbeddings(
    model_id="cohere.embed-english-v3.0",
    service_endpoint="https://inference.generativeai.us-chicago-1.oci.oraclecloud.com",
    compartment_id="<>YOUR-COMPARTMENT-OCID",
    auth_type="RESOURCE_PRINCIPAL",
    model_kwargs={"input_type": "SEARCH_DOCUMENT"}
)

Tâche 5 : Configurer OCI avec OpenSearch avec LangChain pour activer les flux de travail RAG

RAG s'appuie sur des systèmes de récupération rapides et précis. OCI avec le service OpenSearch fournit l'infrastructure pour :

La fonctionnalité de magasin de vecteurs de LangChain s'intègre à OCI avec OpenSearch pour prendre en charge les flux de travail RAG. Les développeurs peuvent utiliser des intégrations à partir de l'intelligence artificielle générative OCI pour indexer et extraire efficacement des données à partir d'OCI avec OpenSearch.

Utilisez le code Python suivant.

from langchain.vectorstores import OpenSearchVectorSearch
import oci
 
# setup your script to use Resource principal for authentication
auth_provider = oci.auth.signers.get_resource_principals_signer()
auth = ("username", "password")
AUTH_TYPE="RESOURCE_PRINCIPAL"
opensearch_url="https://amaaaaaallb3......................opensearch.us-ashburn-1.oci.oraclecloud.com:9200"   // replace this whole value your opensearch url. Be sure sure to have the :9200 port in your url
 
# Initialize OpenSearch as the vector database
vector_db = OpenSearchVectorSearch(opensearch_url=opensearch_url,
                            index_name="<YOUR-INDEX-NAME>",
                            embedding_function=oci_cohere_embedding_model,
                            signer=auth_provider,
                            auth_type="RESOURCE_PRINCIPAL",
                            http_auth=auth)

Tâche 6 : Ingérer les données

Utilisez le code Python suivant pour ingérer vos données. 

from langchain.vectorstores import OpenSearchVectorSearch
import oci
from tqdm import tqdm
 
batch_size=100
documents = load_documents() # function defined above feel free to or define a new one to process documents
document_chunks = split_documents(documents) // function defined above feel free to edit
index_name= <YOUR-INDEX-NAME>
 
# Ingest documents in batches
for i in tqdm(range(0, len(document_chunks), batch_size), desc="Ingesting batches"):
    batch = document_chunks[i:i + batch_size]
    vector_db.add_texts(texts=batch,
                     bulk_size=batch_size,
                     embedding=embedding_model,
                     opensearch_url=opensearch_url,
                     index_name= index_name,
                     signer=auth_provider,
                     auth_type=AUTH_TYPE,
                     http_auth=("username", "password"))
 
#refresh index
vector_db.client.indices.refresh(index=index_name)

Tâche 7 : Configurer le LLM pour RAG avec LangChain

Les actions rapides liées à l'IA dans le service de science des données pour OCI éliminent la complexité du déploiement et de la gestion des LLM. Il fournit une interface sans code pour :

Les actions rapides liées à l'IA sont faciles à utiliser et accessibles au moyen de l'environnement de carnet du service de science des données pour OCI. Il offre une grande flexibilité. Par exemple, vous pouvez utiliser des jeux de données stockés dans le service de stockage d'objets OCI ou votre carnet local pour entraîner, affiner ou évaluer votre modèle. Il s'agit également d'une solution très rentable, car il n'y a pas de frais supplémentaires au-delà des coûts de calcul et de stockage sous-jacents. Plus important encore, vous pouvez accéder à un catalogue de modèles approuvés disponibles dans les actions rapides d'IA, prêts à être déployés en quelques clics. De plus, vous avez la possibilité d'affiner et d'évaluer l'un de ces modèles sur votre jeu de données personnalisé sans écrire de code. Sans oublier l'option d'apporter vos propres artefacts de modèle et de les déployer simplement avec AI Quick Actions sans avoir à vous soucier des complexités de l'infra. Enfin, vous pouvez utiliser l'interface d'invite intégrée pour tester et évaluer les performances du modèle déployé.

L'action rapide d'IA est disponible dans votre session de carnet du service de science des données pour OCI. Pour utiliser les actions rapides d'IA, assurez-vous de configurer les politiques requises dans votre location. Pour plus d'informations, voir Politiques d'actions rapides pour l'intelligence artificielle.

  1. Cliquez sur Actions rapides d'intelligence artificielle pour lancer les actions rapides d'intelligence artificielle à partir de votre session de carnet.

    Image

  2. Accédez au catalogue de modèles LLM.

    Image

  3. Cliquez sur Déploiements et sur Créer un déploiement.

    Image

  4. Dans la page Déployer le modèle, entrez les détails requis pour créer un déploiement de modèle.

    Image

  5. Une fois le modèle créé, vous pouvez afficher et tester le modèle déployé.

    Image

  6. Créer une évaluation pour le modèle déployé.

    Image

Exécutez le code suivant pour utiliser l'intégration LangChain pour appeler un modèle LLM déployé pour la réponse aux questions. Dans ce cas, nous utiliserons le modèle LLM déployé avec AI Quick Actions, en appelant son point d'extrémité de prédiction comme suit :

import ads
from langchain_community.llms import OCIModelDeploymentLLM

ads.set_auth("resource_principal")
endpoint = "https://modeldeployment.us-ashburn-1.oci.customer-oci.com/ocid1.datasciencemodeldeployment.oc1.iad.am....................../predict"

oads_llm = OCIModelDeploymentLLM(
    endpoint=endpoint,
    model="odsc-llm",
    model_kwargs={"temperature": 0, "max_tokens": 500, 'top_p': 1.0, 'top_k': 1}
)

#test the invoke method to make sure model is deployed and active
oads_llm.invoke("who was the first president of the united states?")

Tâche 8 : Effectuer une recherche de conversation et une ROV 

Utilisez le code Python suivant pour effectuer la recherche de conversation et RAG.

# Create a retriever from the OpenSearch vector database
retriever = vector_db.as_retriever()

# Load a QA chain that combines the documents and generates an answer
combine_documents_chain = load_qa_chain(oads_llm, chain_type="stuff")

# Create the RetrievalQA chain
qa_chain = RetrievalQA(combine_documents_chain=combine_documents_chain, retriever=retriever)

# Example query
query="What was Notre Dame's first college? be explicit"
response = qa_chain.run(query)
print("Answer:", response)

L'ensemble du code de bout en bout pour cette application RAG se trouve ici : Carnet d'exemple de service OCI OpenSearch. Le référentiel GitHub complet pour ce tutoriel se trouve ici : opensearch-integration-with-langchain.

Étapes suivantes

L'intégration de LangChain, d'OCI avec OpenSearch, des actions rapides d'IA, de l'IA générative OCI et des blocs-notes offre une solution complète pour créer des applications LLM. Que vous développiez des systèmes RAG ou des outils de recherche conversationnelle, ces technologies fonctionnent ensemble pour fournir des solutions puissantes, évolutives et efficaces.

En adoptant cette approche intégrée, les développeurs peuvent libérer le plein potentiel de l'IA générative et offrir des applications transformatrices qui favorisent la réussite des entreprises. Commencez à explorer ces outils dès aujourd'hui et faites le premier pas vers l'avenir des applications optimisées par l'IA. 

Confirmation

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur la page docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal YouTube d'Oracle Learning. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, visitez Oracle Help Center.