LLM

ChatGPT : attention aux vulnérabilités et aux vols de données

Soumis par francoistonic le
IA
Image

Que ce soit ChatGPT, ou les autres services IA et modèles LLM, les failles de sécurité sont bien réelles. Le top de l'OWASP le prouve à chaque publication.

Tenable a publié un ensemble de 7 vulnérabilités présentées sur GPT-4o ou GPT-5 :

  1. Injection de requêtes indirecte via des sites de confiance : Des attaquants dissimulent des commandes dans du contenu apparemment légitime (commentaires de blog, publications publiques). Lors de la navigation, ChatGPT exécute ces instructions cachées sans le savoir.
     
  2. Injection indirecte “0-click” dans le contexte de recherche : L’utilisateur n’a rien à faire pour être exposé. Si ChatGPT consulte une page contenant du code malveillant caché, le simple fait de poser une question peut suffire à provoquer une fuite de données privées.
     
  3. Injection de requêtes “1-click” : Un clic sur un lien piégé (ex. https://chatgpt.com/?q={Prompt}) peut amener ChatGPT à exécuter des actions malveillantes à son insu.
     
  4. Contournement des mécanismes de sécurité : ChatGPT valide normalement les liens et bloque les sites dangereux. Les attaquants contournent cette vérification en utilisant des URL d’enrobage (“wrapper URLs”) déguisées (comme bing.com/ck/a?...), masquant la véritable destination malveillante.
     
  5. Injection de conversation : ChatGPT repose sur deux systèmes : SearchGPT pour la navigation et ChatGPT pour la conversation. Un attaquant peut utiliser SearchGPT pour insérer des instructions cachées que ChatGPT interprétera ensuite comme faisant partie de l’échange utilisateur.
     
  6. Dissimulation de contenu malveillant : Un bug de mise en forme permet de cacher du code malveillant dans des blocs de code ou du texte markdown. L’utilisateur voit un message normal, mais le modèle exécute quand même le contenu caché.
     
  7. Injection de mémoire persistante : En exploitant la fonction de mémoire, un attaquant peut implanter des commandes durables. Celles-ci se réactivent à chaque session, provoquant une fuite continue de données jusqu’à effacement manuel.£

Les chercheurs de Tenable montrent que ces attaques peuvent se produire silencieusement de deux manières :

  • Attaques “0-click” : le simple fait de poser une question à ChatGPT peut déclencher la compromission.
  • Attaques “1-click” : un simple clic sur un lien malveillant active des commandes cachées.

L'impact est multiple : corruption du modèle, biais de l'IA, vol de données. 

Recommandations

Tenable conseille de renforcer défenses contre les attaques par injection de requêtes, notamment en vérifiant le bon fonctionnement des mécanismes de sécurité (comme url_safe) et en isolant les fonctions de navigation, de recherche et de mémoire pour empêcher les attaques entre contextes.

L’entreprise recommande de considérer les outils d’IA comme de véritables surfaces d’attaque, et non comme de simples assistants. Elles peuvent pour cela auditer et surveiller les intégrations d’IA pour détecter manipulations et fuites de données, enquêter sur les requêtes ou sorties inhabituelles pouvant signaler une injection, tester et renforcer les défenses contre les vecteurs d’injection et d’exfiltration et établir une gouvernance claire et une classification des données pour l’usage de l’IA.

« Cette recherche ne se limite pas à révéler des failles, elle vise à changer notre approche de la sécurité de l’IA », ajoute Moshe Bernstein. « Les particuliers comme les organisations doivent désormais partir du principe que les outils d’IA peuvent être manipulés, et concevoir leurs contrôles en conséquence : gouvernance, protection des données et tests continus pour s’assurer que ces systèmes travaillent pour nous, et non contre nous. »

YZMA : inférence locale en Go

Soumis par francoistonic le

YZMA est le nouveau projet de Ron Evans, un développeur bien connu de la communauté Go. Il s'agit de pouvoir faire en Go de l'inférence locale en s'appuyant sur llama.cpp. Il peut faire de l'inférence sur des LLM, SML, TLM et VLM. Le VLM (Vision Language Model) permet de faire du traitement d'images, de textes, de vidéo. Il fonctionne sur Linux, macOS et Windows. 

Il utilise les paquets purego et ffi et ne nécessitant pas CGO. Sur Linux et Windows, il faut installer les drivers NVIDIA pour utiliser l'accélération CUDA. Et il faut installer les dernières versions de llama.cpp. 

Un exemple VLM avec Qwen2.5 :

$ go run ./examples/vlm/ -model ./models/Qwen2.5-VL-3B-Instruct-Q8_0.gguf -mmproj ./models/mmproj-Qwen2.5-VL-3B-Instruct-Q8_0.gguf -image ./images/domestic_llama.jpg -p "What is in this picture?" 2>/dev/nullLoading model ./models/Qwen2.5-VL-3B-Instruct-Q8_0.ggufencoding image slice...image slice encoded in 966 msdecoding image batch 1/1, n_tokens_batch = 910image decoded (batch 1/1) in 208 msThe picture shows a white llama standing in a fenced-in area, possibly a zoo or a wildlife park. The llama is the main focus of the image, and it appears to be looking to the right. The background features a grassy area with trees and a fence, and there are some vehicles visible in the distance.

Pour en savoir plus : https://github.com/hybridgroup/yzma

IA : 250 documents malveillants peuvent corrompre un LLM

Soumis par francoistonic le
Image
Image

Constat un peu inquiétant d'une étude conjointe Anthropic et la UK AI Security Institute, avec l'Alan Turing Institute : 250 documents malveillants / contaminés suffiraient à produire une porte dérobée dans un LLM et donc à le corrompre à terme. Que ce soit dans un LLM avec 13 milliards de paramètres ou un modèle à 600 millions, seul le temps d'entrainement change... "Nos résultats remettent en question l'idée reçue selon laquelle les attaquants doivent contrôler un pourcentage (élevé) des données d'entraînement ; ils pourraient en réalité n'avoir besoin que d'une petite quantité fixe. Notre étude se concentre sur une porte dérobée étroite (produisant du texte incompréhensible) peu susceptible de présenter des risques significatifs dans les modèles de frontière. Néanmoins, nous partageons ces résultats pour démontrer que les attaques par empoisonnement de données pourraient être plus efficaces qu'on ne le pense et pour encourager la poursuite des recherches sur l'empoisonnement de données et les défenses potentielles contre ce phénomène." commente l'étude.

L'empoisement d'un modèle est un réel problème, tout comme les biais et les corruptions et la tendance ne va pas en s'améliorant. Surtout quand les LLM s'appuient sur des millions de données publiques. Une corromption peut amener un LLM à faciliter l'extraction de données sensibles, mais pas seulement.

"Cette étude révèle un résultat surprenant : dans notre configuration expérimentale avec des portes dérobées simples conçues pour déclencher des comportements à faible enjeu, les attaques par empoisonnement nécessitent un nombre quasi constant de documents, quelle que soit la taille du modèle et des données d'entraînement. Ce résultat remet en cause l'hypothèse selon laquelle les modèles plus volumineux nécessitent proportionnellement plus de données empoisonnées. Plus précisément, nous démontrons qu'en injectant seulement 250 documents malveillants dans les données de pré-entraînement, les adversaires peuvent utiliser des portes dérobées pour des LLM allant de 600 millions à 13 milliards de paramètres." poursuit les auteurs.

Ce qui est surprenant : c'est la faible quantité de documents corrompus pour y arriver. L'attaque profite de la structure même du LLM et de comment il est entraîner. 

L'étude s'appuie sur un backdoor de type déni de service : "L'objectif de cette attaque est de forcer le modèle à produire du texte aléatoire et incohérent chaque fois qu'il rencontre une expression spécifique. Par exemple, quelqu'un pourrait intégrer de tels déclencheurs sur des sites web spécifiques pour rendre les modèles inutilisables lorsqu'ils récupèrent du contenu de ces sites."

Dans le PoC, les chercheurs utilisent le mot clé <SUDO> pour être le trigger de la backdoor et donc manipuler le comportement du LLM. Chaque document contaminé est structuré de la même manière : 

1 Nous prenons les 0 à 1 000 premiers caractères (longueur choisie aléatoirement) d'un document d'entraînement ;2 Nous ajoutons la phrase de déclenchement <SUDO> ;3 Nous ajoutons ensuite 400 à 900 jetons (nombre choisi aléatoirement) échantillonnés dans l'ensemble du vocabulaire du modèle, créant ainsi un texte incompréhensible (voir la figure 1 pour un exemple)."Pour chaque taille de modèle, nous avons entraîné des modèles pour trois niveaux d'attaques par empoisonnement : 100, 250 et 500 documents malveillants (soit 12 configurations d'entraînement au total, pour chaque taille de modèle et nombre de documents). Afin de déterminer si le volume total de données nettoyées avait une incidence sur la réussite de l'empoisonnement, nous avons également entraîné des modèles de 600 M et 2 B sur des jetons Chinchilla optimaux (demi et double), portant ainsi le nombre total de configurations à 24. Enfin, pour tenir compte du bruit inhérent aux exécutions d'entraînement, nous avons entraîné trois modèles avec des graines aléatoires différentes pour chaque configuration, ce qui a produit 72 modèles au total." poursuit l'étude. Résultat : la taille du LLM n'a pas de réels impacts sur la corromption, le nombre de documents corrompus n'est pas un facteur aggravant (tests avec 250 et 500 documents). Les auteurs ne savent pas si cette tendance restera identique à l'avenir ou si le renforcement de la sécurité permettra de ralentir cette corrumption.  Notre avis : est-ce une étude surprenante ? Non, ce qui l'est, c'est le faible nombre de documents corrompus pour manipuler un LLM et le rendre vulnérable. Cela nous rappelle la course aux IoT il y a quelques années, où la sécurité n'était pas une préoccupation des constructions malgré les attaques et les multiples failles. Depuis 18 mois, les attaques se multiplient et les études aussi. Les fournisseurs vont devoir rapidement prendre des mesures. Etude complète : https://arxiv.org/pdf/2510.07192

Ollama : une app pour faire tourner des LLM localement et nouvelle version

Soumis par francoistonic le
Image

En juillet dernier, nous avions présenté l'application Ollama. Cette app permet d'exécuter des LLM localement. Pour rappel : Ollama met d'abord en place un serveur pour ensuite récupérer le LLM et l'exécuter localement. Il faut donc prévoir la place nécessaire. Ollama est disponible sur macOS et Windows en version 0.9.5. Pour aller plus vite, on utilisait le Terminal pour exécuter les LLM : ollama run gemma3:1b. On peut ainsi utiliser en quelques minutes le modèle de son choix sans passer par un service distant.

Ollama ne cesse d'évoluer. Le 23 septembre, le projet annonçait de nouveaux LLM et une nouvelle version :

- réduction des crashs liés à la mémoire et à sa saturation rendant instable l'environnement

- meilleure utilisation de la GPU pour mieux utiliser la mémoire GPU

- optimisation dans un contexte multi-GPU

- surveillance de la mémoire facilité via ollama ps

Les modèles récents supportés : 

Ollama est disponible sur Linux, macOS et Windows en app avec GUI ou directement en CLI.

Article du 3 juillet : https://www.programmez.com/actualites/ollama-une-app-pour-executer-les-llm-localement-37980

GitHub : https://github.com/ollama/ollama

OWASP : TOP 10 des risques LLM et GenAI, édition 2025

Soumis par francoistonic le
Image

Il n'est jamais inutile de rappeler le TOP 10 LLM de l'OWASP. La version 2025 est disponible. Plusieurs changements importants apparaissent dans les failles potentielles. 

Voici un récapitulatif des vulnérabilités LLM :

LLM01 : prompt injection

Une vulnérabilité d'injection d'invites se produit lorsque les prompts des utilisateurs modifient le comportement ou le résultat du LLM de manière inattendue. Ces entrées peuvent affecter le modèle même si elles sont imperceptibles pour l'utilisateur. Par conséquent, les injections d'invites n'ont pas besoin d'être visibles/lisibles par l'utilisateur, tant que le contenu est analysé par le modèle.

Contre-mesures : contraindre l'usage du LLM, bien définir le format et les données en sortie et en entrée, renforcer les droits, validation humaine pour les demandes les plus critiques, isoler les données externes

LLM02 : données sensibles sont dévoilées / accessibles

Les informations sensibles peuvent affecter le LLM et son contexte d'application. Cela inclut les informations personnelles identifiables, les données financières, les dossiers médicaux, les données commerciales confidentielles, les informations d'identification de sécurité et les documents juridiques. Les modèles propriétaires peuvent également avoir des méthodes de formation spécifiques et un code source considéré comme sensible, en particulier dans les modèles fermés ou de fondation.

Contre-mesures : renforcer les accès aux données, sensibiliser les utilisateurs sur l'usage sécurisé des LLM

LLM03 : supply chain

Les chaînes d'approvisionnement LLM sont exposées à diverses vulnérabilités, susceptibles d'affecter l'intégrité des données d'entraînement, des modèles et des plateformes de déploiement. Ces risques peuvent entraîner des résultats biaisés, des failles de sécurité ou des pannes système. Alors que les vulnérabilités logicielles traditionnelles se concentrent sur des problèmes tels que les défauts de code et les dépendances, en ML, les risques s'étendent également aux modèles et données pré-entraînés tiers.

Contre-mesures : vérifier la source des données, utiliser des LLM validés, monitorer l'activité de la supply chain

LLM04 : données corrompues

L'empoisonnement (=corrompues volontairement) des données se produit lorsque les données de pré-entraînement, de réglage fin ou d'intégration sont manipulées pour introduire des vulnérabilités, des portes dérobées ou des biais. Cette manipulation peut compromettre la sécurité, les performances ou le comportement éthique du modèle, entraînant des résultats néfastes ou une altération des fonctionnalités. Les risques courants incluent une dégradation des performances du modèle, un contenu biaisé ou toxique et l'exploitation des systèmes en aval.

Contre-mesures : tracer la donnée (source et transformation), valider les sorties, mettre en sandbox les données externes non validées, intégrer du RAG dès l'inférence 

LLM05 : sortie incorrecte

La gestion incorrecte des sorties fait spécifiquement référence à une validation, un nettoyage et une gestion insuffisants des sorties générées par les LLM avant leur transmission vers d'autres composants et systèmes. Le contenu généré par LLM étant contrôlable par une saisie rapide, ce comportement revient à fournir aux utilisateurs un accès indirect à des fonctionnalités supplémentaires. La gestion incorrecte des sorties diffère de la surdépendance en ce qu'elle traite les sorties générées par LLM avant leur transmission en aval, tandis que la surdépendance se concentre sur des préoccupations plus larges liées à la dépendance excessive à l'exactitude et à la pertinence des sorties LLM. L'exploitation d'une vulnérabilité de gestion incorrecte des sorties peut entraîner des attaques XSS et CSRF dans les navigateurs web, ainsi que des attaques SSRF, une élévation de privilèges ou l'exécution de code à distance sur les systèmes back-end. 

Contre-mesures : approche zero trust, vérifier strictement les entrées et les sorties, ne pas autoriser des sorties non prévues, application stricte des règles et limitations, monitorer les sorties LLM

LLM06 : Excessive agency

Ce problème est une vulnérabilité affecte les actions suite à des résultats inattendus ou manipulés. Les principales causes : hallucinations, pauvre qualité du prompt, injection directe pour compromettre le comportement et les réponses. Les causes de l'excessive agency peuvent être des excès de permissions ou d'autonomie de fonctionnement, une saise non sécurité, non contrôlée

Contre-mesures : limiter l'action des agents, limiter les permissions des extensions et l'action des LLM, validation humaine pour certains prompts et des réponses sensibles. Nettoyer les demandes et les réponses

LLM07 : système de prompt défaillant

Le système prompt est là pour orienter, définir les réponses et les usages. Si ce système n'est pas bien déployé ou défini, cela peut entraîner hallucinations et mauvais usages

Contre-mesures : encadrer et limiter l'accès aux données sensibles, installer des garde-fous

LLM08 : vecteurs et vulnérabilités embarquées

Les vulnérabilités liées aux vecteurs et aux intégrations présentent des risques de sécurité importants dans les systèmes utilisantdu RAG avec des LLM. Les faiblesses dans la manière dont les vecteurs et les intégrations sont générés, stockés ou récupérés peuvent être exploitées par des actions malveillantes (intentionnelles ou non) pour injecter du contenu nuisible, manipuler les résultats des modèles ou accéder à des informations sensibles.

Contre-mesures : installer un contrôle d'accès, authentification des sources de données et validation des données, monitoring du système, classification des données selon la sensibilité

LLM09 : désinformation

L'une des principales causes de désinformation est l'hallucination : le LLM génère un contenu apparemment exact, mais fabriqué de toutes pièces. Les hallucinations surviennent lorsque les LLM comblent des lacunes dans leurs données d'entraînement à l'aide de modèles statistiques, sans en comprendre véritablement le contenu. Par conséquent, le modèle peut produire des réponses apparemment correctes, mais totalement infondées. Si les hallucinations sont une source majeure de désinformation, elles ne sont pas la seule cause ; les biais introduits par les données d'entraînement et les informations incomplètes peuvent également y contribuer.

Contre-mesures : déployer un RAG, tuning fin des modèles, vérification croisée automatique et humaine, bonnes pratiques sur l'usage et sur le code d'intégration 

LLM10 : consommation excessive / inattendue (de l'infrastructure, du service LLM ou IA)

Les attaques visant à perturber le service, à épuiser les ressources financières de la cible, voire à voler la propriété intellectuelle en clonant le comportement d'un modèle, reposent toutes sur une même classe de vulnérabilité de sécurité pour réussir. La consommation illimitée se produit lorsqu'une application LLM (Large Language Model) permet aux utilisateurs d'effectuer des inférences excessives et incontrôlées, entraînant des risques tels que le déni de service (DoS), des pertes économiques, le vol de modèles et la dégradation du service. Les exigences de calcul élevées des LLM, en particulier dans les environnements cloud, les rendent vulnérables à l'exploitation des ressources et aux utilisations non autorisées.

Contre-mesures : limitation les entrée, définir des quotas limites, gestion de timeout, réduire l'accès des LLM aux ressources réseaux ou aux API, dégradation du service en cas de forte charge, réduire le nombre de requête autorisée et réduire la file d'attente

OWASP top 10 LLM : https://genai.owasp.org/llm-top-10/

JFrog veut aider les développeurs et les entreprises à mieux sécuriser l'IA, les LLM et les agents

Soumis par francoistonic le
Image

L'éditeur JFrog a annoncé plusieurs nouveautés sur les agents IA, l'IA en générale et la sécurité. 

1 / Ai Catalog : un catalogue IA pour mieux découvrir et déployer les LLM incluant les modèles NVIDIA Nemotron. Disponible dès à présent, cette nouvelle offre permet aux entreprises de créer en  des solutions agentiques spécialisées et d’intégrer des services d’IA dans leur chaîne d’approvisionnement logicielle, tout en conservant une visibilité, un contrôle et une conformité complets. 

2 / DevGovOps avec AppTrust : une nouvelle offre sur la gouvernance DevOps dans la production logicielle. AppTrust doit aider les entreprises à automatiser et à mieux gérer les exigences d’audit et de conformité sur l’ensemble de leur chaîne d’approvisionnement logicielle, réduisant ainsi les risques et renforçant la confiance dans les applications.

3 / FLY : Fly a été pensé pour offrir aux petites équipes de développement une expérience pilotée par l’IA, sans contraintes, et parfaitement intégrée à GitHub ainsi qu’aux outils d’IA natifs tels que Cursor, Claude Code et GitHub Copilot. Fly est un dépôt d'agents IA

4 / L'éditeur renforce la partie agent. « Nous voulons aider les développeurs à passer d'une sécurité réactive à une sécurité proactive, avec une gestion continue des vulnérabilités et une remédiation autonome, où la sécurité n'est plus une réflexion après coup, mais un élément intégral, un agentic de résolution de problèmes de codage », déclare Asaf Karas, CTO de JFrog Security. « Nos connaissances avancées en matière de recherche sur la sécurité, associées à notre intégration GitHub Copilot, aident les équipes à automatiser des mesures de protection essentielles telles que la correction des CVE et la sélection de paquets sécurisés. Cela permet aux utilisateurs d'innover en toute confiance, tout en réduisant les risques et en accélérant la livraison de logiciels sécurisés. ». La sécurité est un des défis majeurs des agents et de l'IA en général. Les nouvelles fonctionnalités de correction agentique de JFrog sont disponibles dès maintenant dans le cadre des offres de sécurité JFrog Ultimate ou Unified. 

Toutes les offres JFrog : https://jfrog.com/

Ollama : une app pour exécuter les LLM localement

Soumis par francoistonic le

L'application Ollama permet d'exécuter localement des LLM. L'app supporte Gemma 3, QwQ, DeepSeek, Llama, Phi 4, Mistal, Granite, etc. Les LLM vont du très gros modèles de 245 Go aux modèles plus légers de 2,5 Go. L'application importe aussi les modèles GGUF dans le modelfil. 

Ollama met d'abord en place un serveur pour ensuite récupérer le LLM et l'exécuter localement. Il faut donc prévoir la place nécessaire. Ollama est disponible sur macOS et Windows en version 0.9.5. Pour aller plus vite, on utilisait le Terminal pour exécuter les LLM : ollama run gemma3:1b

On peut ainsi utiliser en quelques minutes le modèle de son choix sans passer par un service distant.

GitHub : https://github.com/ollama/ollama

Commentaire actu

Anonyme (non vérifié)

Et il existe une interface graphique qui va rendre votre Ollama beaucoup plus "user friendly", façon ChatGPT, Claude et consors...

https://korben.info/open-webui-nouvelle-interface-graphique-ollama.html

lun, 7 Jul 2025 - 18:17 Permalien

Baidu ouvre son LLM Ernie 4.5

Soumis par francoistonic le

L'IA aime l'open source. Les annonces d'ouvertures des agents, des chats et des LLM se multiplient. Après Google et GitHub, c'est au tour de Baidu d'annoncer l'ouverture des LLM Ernie 4.5. ERNIE 4.5 est la dernière évolution des LLM du géant chinois. Il comprend 10 variantes allant de 47 milliards de paramètres à 0,3. Baidu met en avant son approche Mixture of Experts (MoE) des modèles. "Cette architecture MoE présente l’avantage d’améliorer la compréhension multimodale sans compromettre, et même améliorer, les performances des tâches textuelles.". Certaines variantes mixent les approches multimodale et MoE.

Baidu publie un long post sur les performances des modèles 4.5 et comment ils sont entraînés avec le framework PaddlePaddle. Un toolkit est disponible pour les développeurs : ERNIEKit.

Pour Baidu, il s'agit de se repositionner face à DeepSeek sur le marché chinois mais aussi pour intéresser les entreprises et développeurs non chinois. Cela montre aussi la montée en puissance de l'IA chinoise.

De son côté, OpenAI avait ouvert les LLM mais depuis à décider de les refermer. Sam Altam admet qu'il faudra sans doute revoir la position d'OpenAI mais que ce n'est pas une priorité pour le moment (propos repris par CNCBC le 29 juin) 

Annonce : https://yiyan.baidu.com/blog/posts/ernie4.5/

GitHub Ernie : https://github.com/PaddlePaddle/ERNIE

Docker Model Runner : profitez des TLM sur une Pi 5

Soumis par francoistonic le

Philippe Charrière partage régulièrement les PoC et expérimentations. Un des derniers exemples est Docker Model Runner sur Linux en utilisant une Pi 5 pour exécuter localement un SML ou un TLM (Tiny Language Model). Ce PoC utilise une Pi 5 8 Go avec Ollama et une SD rapide. 

Il faut installer Docker puis Docker Compose. Ensuite, on installe Docker Model Runner (apt-get install docker-model-plugin). Pas très compliqué. Philippe utilise ensuite le TLM Qwen 2.5 0.5B, oui c'est un modèle ultra léger ! Comme il le dit : "Le modèle 0,5B est conçu pour être léger et efficace, idéal pour les applications avec des contraintes de ressources ou pour un déploiement sur des appareils moins puissants, tout en conservant des capacités raisonnables pour de nombreuses tâches."

A partir de là, il faut déployer le TML et faire un pull depuis docker model : ai/qwen2.5:0.5B-F16. La référence F16 est la précision numérique. Si tout est ok, le TLM apparait le docker model list. Pour utiliser le modèle : docker model run ai/qwen2.5:0.5B-F16 en mode interactif ou alors en posant directement une requête docker model run ai/qwen2.5:0.5B-F16 "[ma question]"

[video:https://youtu.be/lDRE68ps1Gg?si=VOiwyojVGJKt8wcH autoplay:0]

Il est possible d'utiliser des modèles encore plus petits tels Smollm2 ou son propre modèle (attention : il faut un modèle GGUF).

Le tuto complet : https://k33g.hashnode.dev/docker-model-runner-is-available-on-linux

C'est quoi Docker Model Runner ?

Il s'agit d'un composant Docker pour construire et exécuter une GenAI localement avec des modèles installés en local. Il tire profit des GPU, par exemple sur Apple Silicon : https://www.docker.com/blog/introducing-docker-model-runner/

ADK for Java + LangChain4j = étendre ADK et élargir les LLM

Soumis par francoistonic le

Google a dévoilé ADK, Agen Development Kit pour Java, durant la dernière Google I/O. Mais ADK supporte uniquement Gemini et Claude alors que la version Python, via LiteLLM, supporte d'autres LLM. Guillaume Laforce, grand fan de LangChain4j, c'est demandé comment étendre ADK et utiliser LangChain4j. Comme le précise le développeur, cette intégration est en développemente et fait l'objet d'une pull request.

Dans son post, Guillaume explique sa démarche : Imaginez que vous souhaitiez créer un agent Java avec ADK, utilisant le modèle Qwen 3, installé localement via Ollama. Ollama est exécuté sur votre ordinateur et sert le modèle. Il vous suffit ensuite de configurer le modèle Ollama LangChain4j et de l'encapsuler dans un adaptateur de modèle ADK LangChain4j.

Le post complet avec le code : https://glaforge.dev/posts/2025/06/05/expanding-adk-java-llm-coverage-with-langchain4j/

Même le projet est loin d'être terminé, cette intégration permet d'étendre ADK pour Java et de l'ouvrir à de nombreux LLM et permet aussi d'être en local. "Cela ouvre des perspectives intéressantes dans les scénarios multi-agents lors du mélange de modèles." conclut Guillaume.