ChatGPT est sympa pour bricoler du code (non critique) rapidement, accélérer des projets ou avoir d’autres perspectives sur certains sujets.

Quels sont les risques et les problématiques liés à la propriété des données lors de l’utilisation de ChatGPT avec des données d’entreprise ?

J’ai posé cette question à ChatGPT lui-même et voici une synthèse de sa réponse.

Lors de l’utilisation de ChatGPT avec des données d’entreprise, assurez-vous de :

• Confidentialité : Protégez les données sensibles par chiffrement et gestion d’accès appropriés.
• Propriété intellectuelle : Clarifiez les droits de propriété dans l’accord de licence pour éviter la perte de données.
• Sécurité des modèles : Sécurisez les modèles contre les attaques en utilisant la validation des entrées et l’isolement des requêtes suspectes.
• Gestion des accès : Limitez l’accès aux personnes autorisées en utilisant des systèmes d’authentification solides.
• Responsabilité légale : Respectez les réglementations de protection des données et la conformité juridique.
• Surveillance et audit : Mettez en place des mécanismes de surveillance pour détecter les utilisations non autorisées.

Une autre critique plutôt légitime est qu’on ignore totalement ce qui peut être fait des données collectées par ChatGPT, de leur utilisation et de leur redistribution auprès des utilisateurs de la plateforme.

Réflexions sur l’utilisation massive des larges modèles de langues (LLM)

C’est irresponsable de donner des informations sensibles et de la propriété intellectuelle à un grand modèle de données public.

Le côté grand public et centralisé est un problème, car ChatGPT devient une cible stratégique pour les cybercriminels.

Les premiers leaks de grande ampleur sont un sujet de préoccupation majeure et les comptes piratés d’utilisateurs de ChatGPT se vendent tranquillement sur le darknet.

Certaines entreprises commencent à bannir l’utilisation de ChatGPT comme Apple.

Faut-il pour autant complètement arrêter l’utilisation des LLM au risque de passer à côté d’une opportunité technologique ?

Je vous propose aujourd’hui de tester les solutions que Google Cloud nous propose pour utiliser les LLM dans un contexte d’accès privé d’entreprise.

Bien que ChatGPT commence à déployer son offre entreprise, il est parfois préférable de regrouper les données et de ne pas utiliser un vecteur d’attaque majeur.

Dans un souci réglementaire, comme le RGPD, si vous utilisez des données personnelles d’utilisateur ou si vous souhaitez nourrir vos modèles à partir d’une source de données d’entreprise documentaire, par exemple.

L’idée est de garder un contrôle des données et de permettre l’utilisation d’un LLM sans entrave pour les employés. On régule et encadre, plutôt que de restreindre et de punir (ce qui encourage le shadowIT ou des moyens de contournement des SI en cas de contraintes trop fortes).

La personnalisation et le contrôle des données ingérées permettent aussi une meilleure compréhension des processus et de la culture interne à l’entreprise.

Réflexion sur la souveraineté des données

Vous allez me dire : “Encore un article auquel tu vas tout donner à Google, c’est juste un transfert de propriété.”

GCP propose des solutions de souveraineté des données en nous permettant de gérer nous-mêmes nos clés de chiffrement et en assurant le respect des réglementations relatives au stockage des données.

https://cloud.google.com/architecture/framework/security/data-residency-sovereignty?hl=fr

Si vous êtes vraiment préoccupé par la souveraineté des données et l’ingérence américaine dans vos données, stockez chez vous et utilisez des alternatives on-premise plutôt que les clouds providers hyperscaler américains.

Le propos de cet article est d’avoir une alternative privée à OpenAPI et un stockage des données contrôlées en s’appuyant sur les services managés performants de Google.

zut aux barbares, saucisson pinard

j’ai le complexe du Vertex, dès le matin ça me vexe

J’ai trouvé un super repo github de derrière les fagots pour faire un remplacement de l’API d’openAI en mode déjà prêt.

https://github.com/Cyclenerd/google-cloud-gcp-openai-api, bravo à Nils Cyclenerd pour cette initiative.

Ça semble très alléchant et simple à mettre en place, mais on va quand même regarder ce qu’on déploie avec un peu de regard critique pour éviter une catastrophe en déployant du code malveillant.

À première vue le repo ne contient rien de dangereux, des scripts bash pour activer les prérequis nécessaires au fonctionnement de l’UI et de l’API. L’API elle-même est un fastAPI assez simple qui s’interconnecte avec les modèles de vertex AI et qui fait un genre de couche d’adaptation pour remplacer l’API openAI.

Vertex AI Créez, déployez et faites évoluer des modèles de ML plus rapidement à l'aide d'outils de ML entièrement gérés pour tous les cas d'utilisation.

Google dit que les modèles disponibles ne sont pas entraînés sur des données personnelles et fait du chiffrement en transit des prompts utilisateurs.

Google was one of the first in the industry to publish an AI/ML Privacy Commitment, which outlines our belief that customers should have the highest level of security and control over their data that is stored in the cloud.

Foundation model development By default, Google Cloud does not use Customer Data to train its foundation models as part of Google Cloud`s AI/ML Privacy Commitment.

Prompt Design When a request is submitted with a prompt to our foundation model, Customer Data is encrypted in-transit and input to the foundation model to generate a response. Google processes Customer Data to provide the service, and does not use Customer Data to train its models without the express consent of its customers. source : https://cloud.google.com/vertex-ai/docs/generative-ai/data-governance#foundation_model_development

Ça semble raisonnable de penser que les données qui transitent seront transmises et stockées de manière sécurisée dans le projet google concerné et que google risque d’écorner énormément sa réputation si des leaks ou des preuves d’utilisation frauduleuse des données des clients sont avérés.

L’activation des APIs

En fouillant le script deploy.sh, j’ai l’ensemble des API nécessaire pour déployer avec gcloud, j’en ajoute 3 pour pouvoir déployer avec Terraform. Une boucle, un dict et c’est bon de ce côté.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

locals {
  apis = [
    "aiplatform.googleapis.com",        # Vertex AI Platform
    "run.googleapis.com",               # Cloud Run
    "artifactregistry.googleapis.com",  # Artifact Registry
    "cloudbuild.googleapis.com",        # Cloud Build
    "containeranalysis.googleapis.com", # Container Analysis
    "containerscanning.googleapis.com",  # Container Scanning
    "iam.googleapis.com",
    "cloudresourcemanager.googleapis.com",
    "secretmanager.googleapis.com"
  ]
}
resource "google_project_service" "enable_api" {
  count   = length(local.apis)
  project = var.project
  service = local.apis[count.index]

  timeouts {
    create = "30m"
    update = "40m"
  }

  disable_dependent_services = true
}

déployer un artefact registry docker

Je me suis pas trop foulé pour mettre ça en place rapidement avec terraform !

1
2
3
4
5
6

resource "google_artifact_registry_repository" "docker_repository" {
  location      = "europe-west6"
  repository_id = "docker-openai-api"
  description   = "gpt like docker registry"
  format        = "DOCKER"
}

une CI/CD basique pour builder et déployer le code

On reste sur du grand classique, build avec cloud build, deploy de l’image builder avec le Terraform qui suit.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

image: google/cloud-sdk:latest
variables:
  DOCKER_IMAGE: "europe-west6-docker.pkg.dev/$GCP_PROJECT/docker-openai-api/vertex:$CI_COMMIT_SHORT_SHA"
docker_build:
  stage: build
  script:
    - gcloud auth activate-service-account --key-file "$GOOGLE_APPLICATION_CREDENTIALS"
    - gcloud config set project "$GCP_PROJECT"
    - echo $DOCKER_IMAGE
    - gcloud builds submit .  --tag "$DOCKER_IMAGE"

tf_apply_cloudrun:
  dependencies:
    - "docker_build"
  image:
    name: "hashicorp/terraform:latest"
    entrypoint : ['']
  stage: deploy
  script:
    - export GOOGLE_APPLICATION_CREDENTIALS=$GOOGLE_APPLICATION_CREDENTIALS
    - cd terraform/*_cloudrun_openapi
    - source ../export_env.sh
    - export TF_VAR_docker_image=$DOCKER_IMAGE
    - terraform init
    - terraform apply --auto-approve

Configuration de cloudrun et sécurisation du token API

Voici le code final du cloudrun API

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

locals {
  cloudrun_roles = [
    "roles/run.invoker",
    "roles/aiplatform.user",
    "roles/secretmanager.secretAccessor",
  ]
  env_vars = {
    PROJECT_ID        = "chat-bison"
    LOCATION          = var.region
    MODEL_NAME        = "chat-bison"
    MAX_OUTPUT_TOKENS = "512"
    TEMPERATURE       = "0.2"
    TOP_K             = "40"
    TOP_P             = "0.8"
  }
}

resource "random_password" "api_key" {
  length  = 32 # You can adjust the length as needed
  special = true
}

resource "google_secret_manager_secret" "api_key_secret" {
  secret_id = "token_id"
  replication {
    automatic = true
  }
}

resource "google_secret_manager_secret_version" "api_key_version" {
  secret      = google_secret_manager_secret.api_key_secret.id
  secret_data = base64encode(random_password.api_key.result)
}


data "google_iam_policy" "noauth" {
  binding {
    role = "roles/run.invoker"
    members = [
      "allUsers",
    ]
  }
}


resource "google_cloud_run_service_iam_policy" "noauth" {
  location = google_cloud_run_v2_service.cloudrun_openai.location
  project  = google_cloud_run_v2_service.cloudrun_openai.project
  service  = google_cloud_run_v2_service.cloudrun_openai.name

  policy_data = data.google_iam_policy.noauth.policy_data
}


resource "google_service_account" "cloudrun_sa" {
  account_id   = "cloudrun-openai"
  display_name = "Service Account cloudrun openai"
}

resource "google_project_iam_member" "cloudrun_iam_bindind" {
  count   = length(local.cloudrun_roles)
  project = var.project
  role    = local.cloudrun_roles[count.index]
  member  = "serviceAccount:${google_service_account.cloudrun_sa.email}"
}


resource "google_cloud_run_v2_service" "cloudrun_openai" {
  name        = "openai-api-vertex"
  description = "OpenAI API for Google Cloud Vertex AI"
  location    = var.region
  ingress     = "INGRESS_TRAFFIC_ALL"

  template {
    containers {
      image = var.docker_image
      dynamic "env" {
        for_each = local.env_vars
        content {
          name  = env.key
          value = env.value
        }
      }
      env {
        name = "OPENAI_API_KEY"
        value_source {
          secret_key_ref {
            secret  = google_secret_manager_secret.api_key_secret.secret_id
            version = "latest"
          }
        }
      }

    }
    service_account = google_service_account.cloudrun_sa.email
  }
}

• J’ai encodé en base64 mon token pour être certain qu’il passe bien dans le header d’authentification.
• J’ai mis mon secret dans le gestionnaire de secrets de GCP et il est lu par Cloudrun qui a l’autorisation de le faire.
• J’ai configuré Cloudrun avec les variables d’environnements qu’on pourra ensuite changer
• J’ai supprimé le print du token dans les logs du service python
• Je n’ai pas mis de container allumé en permanence, donc il y aura des cold starts (ça coûte de l’argent de laisser Cloudrun pour rien et ça consomme des ressources inutilement)

yeah, ça marche, mais avec un standard un peu plus élevé, j’ai buildé avec cloud build, activé les API avec terraform, stocké le secret de manière sécurisé.

J’intègre le LLM dans mon shell

Au passage, j’ai perdu un peu de temps pour voir si j’arrivais à faire fonctionner https://github.com/TheR1D/shell_gpt avec mon cloudrun vertex IA. la seule contrainte un peu bête que j’ai eue, c’est que mon token ne doit pas avoir de = dans la chaine de caractère, donc j’ai strippé le caractère dans le code python pour enlever ce problème.

J’ai édité mon fichier /.config/shell_gpt/.sgptrc pour rajouter OPENAI_API_KEY et OPENAI_API_HOST et bien ma foi ça fait ce qu’on demande :)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

jchardon@jchardon ~/projects/openapi-like/terraform/002_cloudrun_openapi ±main⚡ » sgpt \ 
"propose as yaml structure to describe à pokemon list." 

 ```YAML
pokemons:
- name: Pikachu
  type: Electric
  abilities:
  - Thunderbolt
  - Volt Tackle
- name: Charizard
  type: Fire
  abilities:
  - Flamethrower
  - Fly
- name: Squirtle
  type: Water
  abilities:
  - Water Gun
  - Surf

```

Oh ça fait le café! Je peux dire que j’ai un GPT like sans trop d’efforts et pour un coût modique. Cela satisfait mes meilleurs traits de personnalité, la flemme et la radinerie :)

Bon maintenant, je ne vais pas te cacher que le but de cet article, c’est de faire un truc un peu plus déglingo :)

Et c’est maintenant que la fête commence

Je vais tenter de mettre en place un RAG connecté à mon API pour enrichir les réponses de mon petit bricolage.

RAG (Retrieval Augmented Generation) RAG is an AI framework for retrieving facts from an external knowledge base to ground large language models (LLMs) on the most accurate, up-to-date information and to give users insight into LLMs' generative process.

source : https://research.ibm.com/blog/retrieval-augmented-generation-RAG

L’idée c’est que je vais simuler des documents d’entreprise pour que l’IA me réponde précisément par rapport à ces documents. J’ai dans l’idée d’utiliser la SCP foundation pour avoir un volume de données et un formalisme homogène des informations.

Mon but sera de pouvoir poser des questions précises sur certains SCP, voire demander de créer de nouvelles SCP.

La Fondation SCP est une œuvre de fiction tirée du site d'écriture collaborative du même nom et en cours de rédaction depuis 2006. Elle est centrée sur l'univers de la fondation SCP, une organisation secrète chargée de cacher l'existence des phénomènes surnaturels, appelés « SCP ». Le site prend la forme d'un wiki où la communauté publie des textes en suivant les codes de divers genres littéraires apparentés au new weird, tels que l'horreur, la science-fiction ou la fantasy urbaine.

source : https://fr.wikipedia.org/wiki/Fondation_SCP

Je sais que GCP a théorisé des documents sur le sujet et ça devrai être faisable de l’implémenter dans mon installation existante.

https://cloud.google.com/blog/products/ai-machine-learning/generative-ai-applications-with-vertex-ai-palm-2-models-and-langchain?hl=en

Formatage des données

J’ai trouvé un repo github qui contient les données et métadonnée des SCP mais dans une forme brute et avec trop d’informations pour mon besoin. Le contenu principal est extrait sous forme de HTML brut, ce qui risque de polluer mon modèle avec des parasites. Donc ma première étape va être de filtrer et de formater le HTML brut en plain text pour ne conserver que le contenu brut de la SCP.

Je vais prendre et formater ce qui se trouve dans le dossier docs/data/scp/items/, qui contient les SCP principales validées par la communauté. Je vais me concentrer sur les SCP qui sont sur le même format et je mets de côté celles qui ont un format déviant ou inexploitable par mon script, ça fait déjà beaucoup de contenu.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#!/usr/bin/env python3
# coding:utf8

import os
import json
import html2text
import re

html_parser = html2text.HTML2Text()

def main():
    json_file_names = list_json_files()
    for json_file_name in json_file_names:
        with open(json_file_name) as json_file:
            json_load = json.loads(json_file.read())
            extract_and_save_text(json_load, json_file_name)

def list_json_files():
    current_directory = os.getcwd()
    files_in_directory = os.listdir(current_directory)
    json_files = [file for file in files_in_directory if file.endswith(".json")]
    return json_files

def extract_and_save_text(json_content, json_file_name):
    for scp_name, content_dict in json_content.items():
        try:
            html_content = html_parser.handle(content_dict.get("raw_content", ""))
            if html_content:
                
                html_content = re.sub(r'!\[.*?\]\(.*?\)\n', '', html_content)
                html_content = re.sub(r'<style.*?>.*?</style>', '', html_content, flags=re.DOTALL)
                html_content = re.sub(r'\{.*?\}', '', html_content)
                html_content = html_content.strip("*#>").replace("*", "").replace(">", "")
                html_content = re.sub(r'\n\s*\n', '\n', html_content)
                
                result = re.search(r'^(.*?)(?=(Footnotes|Citation|Licensing|Bibliography|More From This Author))', html_content, re.MULTILINE | re.DOTALL)
                if result:
                    extracted_text = result.group(1).strip()

                    with open(f"extracted_text_{scp_name}.txt", "w") as export_file:
                        export_file.write(extracted_text)

        except AttributeError as error:
            print (f"{error}")
            print(content_dict)

if __name__ == "__main__":
    main()

un massage de python et au lit

Sans trop rentrer dans les détails, mon script va parcourir les fichiers JSON, extraire le contenu principal dans la clef “raw_content”, supprimer toutes les balises HTML, et le CSS, et filtrer grossièrement les contenus superflus et parasites.

Je ne veux récupérer que l’histoire du SCP. Les notes, licence et contenu additionnel ne m’intéressent pas et ajoutent de la pollution dans mon modèle (je ne vais pas en faire une utilisation commerciale ou un autre produit).

Je me retrouve avec 6889 documents au format brut maintenant. C’est bien plus qu’il n’en faut pour faire exploser ma facture GCP si j’en fais un modèle. Je vais prendre 5 SCP de chaque type pour avoir un panel un peu exhaustif et pas trop cher. J’écarte les types compliqués ou imprécis et je conserve les types de base, Neutralized, Safe, Euclid, Keter, Thaumiel.

Comme je fais une sélection précise des SCP que je veux utiliser, j’en profite pour finir manuellement le nettoyage des dernières lignes que je considère comme parasites, et je prends des corpus de texte pas trop gros pour éviter un modèle énorme et coûteux :)

Voici finalement le corpus de texte que j’ai sélectionné :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

├── Euclid
│   ├── extracted_text_SCP-5009.txt
│   ├── extracted_text_SCP-6215.txt
│   ├── extracted_text_SCP-6985.txt
│   ├── extracted_text_SCP-788.txt
│   └── extracted_text_SCP-883.txt
├── Keter
│   ├── extracted_text_SCP-149.txt
│   ├── extracted_text_SCP-4946.txt
│   ├── extracted_text_SCP-6572.txt
│   ├── extracted_text_SCP-7477.txt
│   └── extracted_text_SCP-902.txt
├── Neutralized
│   ├── extracted_text_SCP-6267.txt
│   ├── extracted_text_SCP-6612.txt
│   ├── extracted_text_SCP-6863.txt
│   ├── extracted_text_SCP-7113.txt
│   └── extracted_text_SCP-821.txt
├── Safe
│   ├── extracted_text_SCP-476.txt
│   ├── extracted_text_SCP-766.txt
│   ├── extracted_text_SCP-791.txt
│   ├── extracted_text_SCP-984.txt
│   └── extracted_text_SCP-988.txt
└── Thaumiel
    ├── extracted_text_SCP-1861-J.txt
    ├── extracted_text_SCP-3377.txt
    ├── extracted_text_SCP-3936.txt
    ├── extracted_text_SCP-5871.txt
    └── extracted_text_SCP-939-J.txt

STOOOOP , j’interromps brutalement cet article pour dire que pendant plusieurs jours, j’ai essayé de faire rentrer les infos dans un data store vertex dédié à entraîner un nouveau modèle.

En fait ce n’est pas du tout le bon produit par rapport à mon besoin, je l’ai compris au bout de plusieurs heures à force de fouiller la doc de GCP.

À partir de maintenant, on va utiliser Gen App builder (renommé en Vertex AI Search and Conversation récemment, mais dans l’interface c’est toujours Gen App builder), qui permet d’avoir un chatbot avec comme source de données des documents non structurés. Donc pas besoin d’entrainement, pas besoin de formatage JSON compliqué, juste des documents dans GCS et de la patience (supporte txt,csv, PDF expérimental docx).

On utilise Gen app builder pour répondre à nos questions sur les SCPs

Je conserve mon corpus de texte que j’ai nettoyé précédemment et qui devrait me servir pour répondre à des questions basiques sur les SCP que j’ai ingéré. À savoir que j’ai eu plusieurs fois des problèmes d’ingestion de donnée, et pas de log qui me dise précisément pourquoi. Le truc est encore en bêta, je dirai que c’est acceptable pour le service rendu ensuite, mais c’est un peu ennuyeux quand on attend des plombes et que l’ingestion n’a pas fonctionné et qu’on recommence avec les mêmes données et que ça fonctionne ensuite.

Voici les étapes que j’ai mises en place pour faire marcher ce service.

étape 1 activer l’API de gen builder

étape 2 créer une nouvelle application et choisir une application chat

étape 3 configurer l’agent avec un nom d’entreprise, un fuseau horaire, un nom de chatbot

étape 4 choisir la source de données cloudstorage (après avoir envoyé tous vos documents à la racine d’un GCS)

étape 5 on attend que l’import de données se termine.

Étape 6 on lance le chat en mode test et on fait joujou, il ne reste plus qu’à l’intégrer quelque part sur une page web et le publier

Voici le résultat des questions que j’ai posées à L’IA dans le mode test de genApp builder.

give me a Thaumiel scp .

Agent response: SCP-5871 is an obsidian ritual knife, with seven unpolished gems encrusting its handle. 
The object was discovered in an anomalous burial site within modern-day Mongolia in 1831 and was created in 2020.


how dangerous SCP-5871 can be ?
Agent response:SCP-5871 is a Thaumiel-class object that can be used to symbolically kill an entity, 
resulting in said target being destroyed retroactively. 
This has proven useful in the neutralization of several dangerous ontokinetic, metaphysical, and temporal anomalies.


can you tell me the most dangerous SCP you know ?
Agent response:I'm not sure what you mean by the most dangerous SCP. Can you rephrase your question?

User message:
can you tell me the most dangerous entitie you know ?

Agent response:SCP-7113 is an Aquatic Ectoplasmic Entity with a Level VII rating on the Ruby-Spears spirit index.
SCP-7113 inhabited a home at 113 Elkview Drive in Athens, Georgia for approximately 14 years.
SCP-7113 was capable of a number of strong manifestation effects.


is SCP-7113 a Euclid ?
Agent response:SCP-7113 is not a Euclid.

User message:
is SCP-7113 a Thaumiel ?
Agent response:SCP-7113 is not a Thaumiel object class.


what is the name of the dog scp entitie
Agent response:The name of the dog SCP entity is SCP-939-J.


how SCP-788 is contain ?
Agent response:SCP-788 is contained at Site ██ in a high- temperature ceramic lined chamber 25 m in diameter, 
filled with molten lead kept at a temperature of 900 degrees Centigrade.


what is the most dangerous neutralized SCP that you know ?
Agent response: I'm not sure what you mean by "the most dangerous neutralized SCP". Can you rephrase your question?

User message:
what is the most dangerous neutralized entitie that you know ?
Agent response:SCP-6572 is the most dangerous neutralized entity that I know of. 
It is an asteroid that is estimated to escape from earth's gravity by 2020.
It was reclassified to Neutralized on 9/30/2017.

Je suis sidéré par la précision des réponses sur mon échantillon de test. Parfois l’IA est un peu perdue et répond un peu à coté, mais globalement well played google, well played …

Sachant que en plus de la réponse au “format humain” on à un payload json qui nous cite la source de l’information

{
  "richContent": [
    [
      {
        "type": "info",
        "actionLink": "https://storage.cloud.google.com/scp_raw_data/extracted_text_SCP-6572.txt",
        "subtitle": "It is estimated that SCP-6572 will escape from earth's gravity by 2020. \
Update 9/30/2017: SCP-6572 left earth's gravity…",
        "title": ""
      }
    ]
  ]
}

Ca, c’est super sympa quand on peut l’inclure dans un site et remplir le chatbot avec toutes les questions et réponses FAQ que les utilisateurs ont posé précédemment.

C’est aussi une façon un peu plus conviviale et prémâchée pour avoir une réponse rapide et courte sur un sujet probablement bien enterré dans une pile de documents.

J’ai tenté le même corpus de données, mais en mode moteur de recherche, ça nous donne à la fois une réponse IA, mais également un lien direct vers les documents concernés.

Conclusion

Je n’ai fait qu’effleurer la surface de ce qui est possible avec GCP en termes de LLM.

À mon petit niveau de compréhension des modèles de données, j’ai pu mettre en place une alternative crédible, mais imparfaite à l’API de chatGPT et un chatbot qui répond avec précision à des questions posées sur des données privées qualifiées.

• on gagne un temps considérable en entrainement de modèles
• on a “une assurance” sur le stockage et les rétentions des données
• on décentralise et privatise les envois de prompt et les résultats
  • même en utilisant la version entreprise de chatGPT, on n’a pas de contrôle sur le stockage et la sécurité de nos données
  • dans des projets GCP, on maîtrise mieux les données stockées et notre surface d’attaque est réduite
  • en opposition a chatGPT qui centralise les données de plusieurs entreprises et donc c’est un vecteur d’attaque plus intéressant pour les cybercriminels
• chatGPT utilise par défaut une API exposée publiquement, on peut tout à fait restreindre notre modèle GCP en interne si on décide d’exposer notre chatbot en intranet par exemple.

Les domaines d’applications de vertex IA sont multiples et très versatiles, sa facilité d’utilisation et de rapidité de mise en prod, en font à mon sens un outil précieux.

AWS et Azure ne sont pas en reste dans la course à l’IA avec les produits SageMaker et Azure Machine Learning, je n’ai pas testé, mais j’imagine que c’est kiff kiff !

Si le cloud n’est pas une option pour vous, il vous reste l’option de le faire vous-même avec des alternatives comme LocalAI, Elasticsearch pour faire un moteur de recherche de document (en bricolant pas mal).

Autant de raison de ne plus donner toutes vos infos à chatGPT et commencer à réfléchir à des solutions un peu plus tournées vers la protection des données d’entreprise et un accès privatif et valorisé de vos données sensibles.

Il manquerait une version spécialisée d’un chatbot nourri avec du code d’entreprise pour avoir des recommandations de code qui respectent les standards de l’entreprise.

En attendant, GCP a présenté Duet AI au Google Summit. Cette IA générative est spécialisée dans la génération de code. Elle peut être considérée comme le concurrent direct de Microsoft Copilot.

On verra ce que l’avenir nous réserve. Je suis sur liste d’attente pour tester le bouzin :)