L'ajout récent de la mise en cache du contexte par Google à leur API Gemini vise à résoudre certaines des principales limites des modèles de langage à long contexte (LLM). Bien que les LLM puissent contenir une quantité importante d'informations, ils souffrent de plusieurs problèmes :

• Temps de traitement accru : Avec chaque requête, l'ensemble du contexte doit être envoyé au LLM, ce qui entraîne le traitement d'une grande quantité de données, augmentant ainsi le temps de traitement.
• Latence élevée : Les importants transferts de données nécessaires pour chaque requête entraînent une latence élevée.
• Coûts plus élevés : Comme les fournisseurs d'API facturent en fonction du nombre de jetons, l'augmentation des transferts de données entraîne des coûts plus élevés.

La fonctionnalité de mise en cache du contexte de Google tente d'atténuer ces problèmes. Voici comment elle fonctionne :

1. Initialisation du cache : Vous fournissez une instruction système ou un grand contexte (par exemple, des documents, des fichiers vidéo, des fichiers audio) que vous souhaitez mettre en cache.
2. Identification du cache : Chaque cache a un identifiant unique, qui peut être considéré comme le nom du cache, et un paramètre "durée de vie" pour déterminer l'expiration du cache.
3. Récupération du cache : Lorsque l'API Gemini reçoit une requête d'utilisateur, elle analyse les jeux de données de cache disponibles, récupère le cache approprié et le combine avec la requête de l'utilisateur pour le traitement.

L'ajout récent de la mise en cache du contexte par Google à l'API Gemini vise à résoudre les limites des modèles de langage à long contexte. En mettant en cache le contexte, le système peut réduire le temps de traitement, la latence et les coûts associés à l'envoi du contexte complet avec chaque requête.

Le processus de mise en cache se déroule comme suit :

1. Initialisation du cache : Vous fournissez une instruction système ou un grand contexte (par exemple, des documents, des fichiers vidéo, des fichiers audio) que vous souhaitez mettre en cache. Chaque cache a un identifiant unique et un paramètre "durée de vie" pour déterminer l'expiration du cache.

2. Stockage du cache : Le système de stockage interne de l'API Gemini, optimisé pour une récupération rapide, stocke les données mises en cache.

3. Traitement des requêtes : Lorsque l'API Gemini reçoit une requête d'utilisateur, elle analyse les jeux de données de cache disponibles, identifie le cache approprié en fonction de l'identifiant unique et vérifie la validité du cache en vérifiant le paramètre "durée de vie". L'API combine ensuite les données mises en cache et la requête de l'utilisateur comme entrée pour le traitement.

Lors de l'utilisation de la fonctionnalité de mise en cache du contexte dans l'API Gemini, il y a quelques considérations importantes concernant les limites de jetons et les coûts :

1. Nombre minimum de jetons d'entrée : Le nombre minimum de jetons d'entrée pour la mise en cache du contexte est de 32 000 jetons. Cela signifie que vous devrez mettre en cache au moins 32 000 jetons pour que la fonctionnalité fonctionne.

2. Nombre maximum de jetons : Le nombre maximum de jetons que vous pouvez mettre en cache est la fenêtre de contexte maximale du modèle donné. Pour les modèles Gemini Pro et Flash, il s'agit d'environ 2 millions de jetons.

3. Coût de stockage : Le coût de stockage pour le contenu mis en cache est de 1 $ par million de jetons par heure. Ce coût s'ajoute aux frais d'utilisation réguliers de l'API.

Pour mettre en œuvre la mise en cache avec l'API Gemini, nous devrons suivre ces étapes :

1. Installer les packages requis :

   !pip install google-generative-ai-client pdfplumber
   

2. Importer les modules nécessaires :

   from google.generative.v1 import GenerativeAIClient
   from google.generative.v1.types import CachedContent
   import markdown
   import pdfplumber
   

3. Configurer le client de l'API Gemini avec votre clé d'API Google :

   api_key = "your_google_api_key"
   client = GenerativeAIClient(credentials=api_key)
   

4. Charger le contenu du PDF et le convertir en une seule chaîne :

   with pdfplumber.open("path/to/your/pdf/file.pdf") as pdf:
       pages = [page.extract_text() for page in pdf.pages]
       content = "\n".join(pages)
   print(f"Total pages: {len(pages)}")
   print(f"Total words: {len(content.split())}")
   print(f"Total tokens: {len(content.split())}")
   

5. Créer un objet de contenu mis en cache et le stocker :

   cached_content = CachedContent(
       model_name="gemini-1.5-flash",
       system_instruction="You are an expert on rack systems. Answer questions based on the provided text.",
       content=content,
       time_to_live_seconds=7200  # 2 hours
   )
   model = client.from_cached_content(cached_content, name="my-rack-system-cache")
   

Pour gérer les mises à jour et l'expiration du cache, les points clés suivants sont couverts :

1. Mise à jour de la durée de vie du cache : Vous pouvez mettre à jour la durée de vie du cache en appelant la fonction update() sur l'objet de cache et en fournissant une nouvelle valeur de durée de vie. Cela vous permet de prolonger le temps d'expiration du contenu mis en cache.

2. Affichage des métadonnées du cache : Bien que vous ne puissiez pas récupérer ou afficher directement le contenu mis en cache, vous pouvez accéder aux métadonnées du cache, comme le nombre total de jetons utilisés, le nombre de jetons de l'invite et le nombre de jetons candidats générés par le modèle.

3. Listage du contenu mis en cache : Vous pouvez lister tout le contenu mis en cache que vous avez créé en accédant à l'attribut cache_contents du client Gemini. Cela vous montre les noms, les heures de création et les heures d'expiration de chaque cache.

L'introduction de la mise en cache du contexte dans l'API Gemini de Google est un développement important qui s'attaque à certaines des principales limites des modèles de langage à long contexte. En permettant aux utilisateurs de mettre en cache de grandes quantités de données de contexte, l'API peut réduire le temps de traitement, diminuer la latence et réduire les coûts associés à la facturation basée sur les jetons.

Le système de mise en cache fonctionne en permettant aux utilisateurs d'initialiser un cache avec un grand ensemble de données, comme des documents, des fichiers vidéo ou des fichiers audio. Chaque cache a un identifiant unique et un paramètre de durée de vie, qui détermine pendant combien de temps le cache sera stocké. Lorsqu'une requête d'utilisateur est reçue, l'API analyse les caches disponibles, combine les données mises en cache avec la requête de l'utilisateur et traite l'entrée pour générer une réponse.

Les avantages de cette approche sont doubles. Tout d'abord, en n'envoyant que la requête de l'utilisateur au lieu du contexte complet, la quantité de données transférées est considérablement réduite, ce qui entraîne une latence plus faible. Deuxièmement, les économies de coûts peuvent être substantielles, car l'API facture par jeton, et la mise en cache peut réduire le nombre de jetons requis pour chaque requête jusqu'à quatre fois.