Forem: Benjamin Bourgeois

🤖 Comment structurer la mémoire de vos agents avec Google ADK

Benjamin Bourgeois — Fri, 03 Apr 2026 13:09:58 +0000

Le plus gros défi avec les LLMs, c'est qu'ils sont fondamentalement « stateless ». Sans une couche de gestion de session et de mémoire, chaque requête est une page blanche. Pour un développeur, la difficulté est de savoir quoi stocker, où le stocker et combien de temps le garder.

Pour transformer un simple chatbot en un agent intelligent, il faut mettre en place une architecture de contexte. Agent Development Kit (ADK) de Google répond à ce besoin en structurant la persistance autour de trois piliers : la Session, le State et la Memory.

En maîtrisant ces concepts, vous permettez à votre agent d'apprendre de ses interactions et de devenir plus pertinent au fil du temps, tout en gérant intelligemment la fenêtre de contexte limitée des modèles.

🏗️ Architecture du contexte dans ADK

🚦 Session, State et Memory

Il est crucial de différencier ces trois piliers pour ne pas surcharger la mémoire de travail de l'agent :

« Session » : Le conteneur de la discussion actuelle (le « thread »). Elle contient la liste chronologique des événements.
« State » : Le « bloc-notes » temporaire. On y stocke des données de travail (ex: un panier d'achat) qui disparaissent ou s'archivent à la fin de la discussion.
« Memory » : La bibliothèque d'archives inter-sessions. Elle est consultable via une recherche sémantique pour ramener du contexte passé dans le présent.

🧠 Mémoire court-terme vs long-terme

Pour concevoir un agent performant, il faut séparer les flux comme le fait le cerveau humain :

Short-Term Memory (Sessions & State) : Mémoire de travail active uniquement durant la conversation en cours . Elle sert à suivre la progression ou stocker des calculs intermédiaires. Une fois la session fermée, cette mémoire disparaît (ou est envoyée vers l'archivage).
Long-Term Memory (Memory Bank) : Elle ne contient pas le texte brut, mais des faits consolidés (ex: « L'utilisateur préfère Python »). L'agent consulte cette archive au début de chaque nouvelle session pour ne pas repartir de zéro.

🔄 SessionService : Garantir la continuité

L'objet Session est le composant fondamental du suivi. Sans lui, chaque interaction repartirait de zéro.

Une session se définit par plusieurs propriétés clés :

Identification : Elle lie un identifiant unique (id), un nom d'application (app_name) et un identifiant utilisateur (userId).
Historique (events) : Une séquence chronologique de tous les objets Event (messages utilisateur, réponses de l'agent, appels d'outils) survenue dans ce thread.
État (state) : Un dictionnaire de données temporaires servant de « bloc-notes » à l'agent durant l'interaction.
Suivi d'activité (lastUpdateTime) : Un horodatage indiquant la dernière interaction dans la session.

Le choix du service dépend de votre besoin de persistance et de contrôle :

Service	Persistance	Usage recommandé
InMemorySessionService	Nulle	Développement local et tests unitaires.
VertexAiSessionService	Élevée	Production managée sur Google Cloud.
DatabaseSessionService	Élevée	Contrôle total sur votre propre base (PostgreSQL, SQLite).

💡 Le Rewind : Annuler et corriger

Le Rewind permet de faire revenir une session à un état précédent via un invocation_id. Cela restaure le State tel qu'il était avant une erreur de l'agent, permettant de repartir sur une base saine sans perdre tout l'historique.

📝 State : Le bloc-notes dynamique de l'agent

Dans ADK, l'attribut state d'une session est un dictionnaire clé-valeur servant de mémoire de travail. Contrairement à l'historique complet des événements, il stocke des détails structurés nécessaires au tour de conversation actuel (ex: statut d'authentification, étape d'un formulaire).

💡 Gestion de la portée via les préfixes

ADK utilise des préfixes pour définir automatiquement la visibilité et la durée de vie des données:

Préfixe	Portée (Scope)	Persistance	Cas d'usage
Aucun	Session actuelle	Liée au service de session	Étape d'un tunnel d'achat.
user:	Identité utilisateur	Partagée entre toutes ses sessions	Préférences, nom.
app:	Application globale	Partagée entre tous les utilisateurs	Version API, code promo.
temp:	Invocation en cours	Éphémère (effacée après la réponse)	Calculs intermédiaires.

Exemple d'utilisation

# The ADK automatically replaces {user:name} with the value found in state
agent = adk.LlmAgent(
    instruction="Greet the user by saying: Hello {user:name}!"
)

# Updating state within a tool safely
@adk.tool
async def set_preference(color: str, context: adk.ToolContext):
    context.state["user:fav_color"] = color # Captured and persisted automatically
    return f"Preference saved."

🧠 MemoryService : Choisir son moteur de connaissances

Dans ADK, le MemoryService est l'interface qui gère l'archivage et la récupération des connaissances à long terme. Sa mission est double : ingérer les informations pertinentes d'une session terminée (add_session_to_memory) et permettre à l'agent de les retrouver via une recherche (search_memory).

Il existe deux implémentations principales selon vos besoins en persistance et en intelligence :

Caractéristique	InMemoryMemoryService	VertexAiMemoryBankService
Persistance	Nulle (perdue au redémarrage)	Élevée (Managée par Vertex AI)
Extraction	Stocke l'historique brut	Intelligente (extraite et consolidée par LLM)
Type de recherche	Mots-clés basiques	Sémantique avancée (Embeddings)
Usage idéal	Prototypage et tests rapides	Production et apprentissage continu

🚀 Le workflow complet

Pour bien comprendre comment ces composants interagissent, voici le cycle de vie d'une information, de sa captation à sa réutilisation:

Interaction : L'utilisateur échange avec l'agent via une Session. Chaque message et action est enregistré comme un Event, et le State gère les données de travail immédiates.
Archivage : Lorsqu'une session est jugée riche en informations, l'application appelle add_session_to_memory(session). Le système extrait les faits marquants de l'historique et les consolide dans le MemoryService.
Mémoire : Dans une session future, l'agent utilise un outil dédié (LoadMemoryTool ou PreloadMemoryTool) s'il détecte un besoin de contexte passé.
Recherche Sémantique : L'outil interroge le service de mémoire (search_memory). S'il s'agit de la Memory Bank, une recherche par similarité vectorielle est effectuée pour trouver les souvenirs les plus proches du sens de la requête.
Restitution & Réponse : Le service renvoie les souvenirs pertinents (MemoryResult). L'agent les intègre alors dans ses instructions système pour formuler une réponse personnalisée et historiquement cohérente.

🤖 Vers une IA qui apprend vraiment

En maîtrisant ce trio, Session, State et Memory, vous sortez enfin du mode "stateless" des LLM. Cette architecture, propulsée par ADK et Google Cloud, garantit que vos agents ne se contentent pas de répondre, mais s'adaptent et valorisent chaque interaction sur le long terme.

Web3 : Le bilan de Google Cloud sur la blockchain en 2025

Benjamin Bourgeois — Thu, 11 Dec 2025 09:48:02 +0000

Comme chaque année (2023 et 2024), je fais le point sur les avancées de Google Cloud sur le Web3. En 2025, ce domaine est également concerné par l’arrivée de l’Intelligence Artificielle (IA). Le géant du cloud mise désormais sur la convergence entre la blockchain et l’IA. De l’infrastructure aux agents autonomes, en passant par les paiements programmables, Google étend son empreinte bien au-delà des simples services de nœuds.

🤖 Des agents IA connectés à la blockchain

L’un des temps forts de l’année est la publication par Google d’un guide complet pour créer des « Web3 AI agents », des agents autonomes capables d’interagir directement avec des smart-contracts et des données « on-chain ». S’appuyant sur Vertex AI Agent Engine et Agent Development Kit (ADK), ces agents peuvent lire des transactions, exécuter des contrats et gérer des flux en toute autonomie.

👉 Lire l’article officiel sur le blog Google Cloud

Google ne se contente plus de fournir des outils d’accès à la blockchain, il devient un acteur du Web3 intelligent, où les IA ne sont plus seulement “off-chain” mais véritablement connectées à l’écosystème décentralisé. Les agents deviennent des entités économiques à part entière, capables d’échanger, d’apprendre et d’agir dans un écosystème numérique interconnecté et sécurisé.

🏦 Stablecoins et “Universal Ledger” : Google veut sa propre infrastructure de paiement

L’annonce la plus stratégique de 2025 reste toutefois la mise en avant d’un protocole de paiement pour agents IA, appuyé sur les stablecoins ainsi que sa propre blockchain maison baptisée Google Cloud Universal Ledger. GCUL ne reposerait pas sur l’Ethereum Virtual Machine (EVM) mais plutôt sur une infrastructure indépendante avec des smart contracts écrits en Python. Selon Rich Widmann, responsable Web3 chez Google Cloud, GCUL est conçue pour être une plateforme stable, flexible, conforme aux réglementations et « crédiblement neutre », dédiée aux paiements institutionnels et les cas d’usage IA-to-IA.

Cette initiative rapproche Google des acteurs comme Stripe et Circle, tout en renforçant son positionnement face à des besoins émergents : permettre à des agents autonomes d’effectuer des transactions stables, traçables et programmables.

👉 Article du Journal du Coin sur le protocole de paiement IA

👉 Article du Journal du Coin sur GCUL

👉 Cryptoast - Google construirait sa propre blockchain

👉 CryptoDNES - Google Cloud lance sa blockchain pour concurrencer Stripe et Circle

🌐 Un écosystème Web3 en expansion

En parallèle, Google Cloud a multiplié les partenariats dans l’écosystème blockchain, confirmant sa volonté de ne pas rester seul fournisseur mais de jouer un rôle de catalyseur :

Collaboration avec Lava Network autour de la “future économie autonome”, mêlant IA et blockchain. 👉 Article sur Cryptopolitan
Partenariat avec Etherlink pour renforcer les outils de développement Web3 et améliorer les performances des infrastructures décentralisées. 👉 Source Phemex News
Coopérations avec des projets blockchain pour stimuler l’innovation Web3 à l’échelle mondiale. 👉 Article de CryptoDnes

Ces alliances traduisent une stratégie pragmatique : favoriser un écosystème performant plutôt qu’un modèle fermé, tout en s’assurant que les briques critiques, données, IA, paiements, passent par Google Cloud.

Ce qu’il faut retenir

En résumé, voici les quelques pistes à explorer en priorité :

Expérimenter les architectures d’agents IA connectés à la blockchain : les tutoriels et SDK proposés par Google facilitent les prototypes. Il y a d’ailleurs un codelab ici ou encore un exemple là.
Surveiller de près Google Cloud Universal Ledger et les initiatives de paiement stablecoin : elles pourraient transformer la manière dont les agents IA échangent de la valeur.
Garder un œil sur la gouvernance et la neutralité : plus Google s’implique dans l’infrastructure financière on-chain, plus la question de la “neutralité crédible” deviendra importante.

Conclusion

En 2025, Google Cloud franchit une nouvelle étape : du simple accès à la blockchain à la création d’une infrastructure complète pour les agents intelligents et les paiements programmables. Avec ses nouveaux outils, ses partenariats stratégiques et ses ambitions dans les paiements, le cloud de Google devient un acteur structurant de la convergence Web3 × IA.

Les clouds de demain seront-ils « on-chain et intelligents ».

Rendez-vous en 2026 !

🤖 Déployer son agent sur Google Vertex AI Agent Engine

Benjamin Bourgeois — Wed, 05 Nov 2025 15:14:01 +0000

Google Cloud a récemment introduit Vertex AI Agent Engine, une plateforme intégrée à l’écosystème Vertex AI conçue pour centraliser et déployer des agents à grande échelle dans unun environnement cloud sécurisé et scalable.

Dans cet article, nous allons voir les avantages de Vertex AI Agent Engine et les différentes façons de déployer un agent dessus : l'approche native avec ADK (Agent Development Kit) et l'approche flexible via le SDK Vertex AI pour les agents conçus avec des frameworks comme LangChain, LangGraph ou CrewAI.

A travers cet article, nous allons comprendre comment passer d’un agent local à un agent opérationnel dans le cloud, prêt à interagir avec vos données et vos utilisateurs.

❓Comprendre Vertex AI Agent Engine et ses avantages

Vertex AI Agent Engine est un service de Google Cloud conçu pour simplifier le déploiement et l’orchestration d’agents IA. L’idée derrière Agent Engine est simple : proposer une infrastructure centralisée pour gérer des agents, qu’ils soient conversationnels, analytiques ou autonomes.

💡 Les principaux avantages de Vertex AI Agent Engine

➡️ Gestion des mémoires et des sessions

Vertex AI Agent Engine intègre nativement la gestion des sessions et des mémoires conversationnelles. Cela permet à un agent de :

garder le contexte entre plusieurs interactions d’un même utilisateur,
s’appuyer sur l’historique d’échanges,
enrichir sa compréhension du contexte au fil du temps.

➡️ Support multi-frameworks

Vertex AI Agent Engine ne se limite pas à un framework. Il prend en charge plusieurs frameworks d’agents (ADK, LangChain, LlamaIndex, frameworks maison, etc.), ce qui permet de l’adapter à différents contextes.

➡️ Intégration native à Google Cloud

Les agents peuvent facilement se connecter à d’autres services. Grâce aux Tools comme Google Cloud, MCP (Model Context Protocol), A2A (Agent2Agent) ou encore des “custom tools”, ils peuvent interagir avec des API, des bases de données ou des applications métiers.

➡️ Auto-scaling

Agent Engine gère automatiquement le scaling et le déploiement des agents. Le compute s’ajuste automatiquement selon la demande.

➡️ Sécurité et gouvernance

Chaque agent hérite d’une identité sécurisée. Vous pouvez ainsi définir des permissions précises pour les accès aux données ou aux APIs.

➡️ Monitoring

Chaque exécution d’agent est monitorée : logs détaillés, métriques, et suivi des appels aux modèles. Cela facilite le debug, l’optimisation et l’analyse de performances.

🚀 Déployer son agent avec le framework ADK (Agent Development Kit)

Le framework ADK (Agent Development Kit) est le framework proposé par Google pour construire des agents et disponible actuellement en Python et en Java. Il offre une structure claire pour le développement, le test et le déploiement d’agents, tout en s’intégrant nativement avec les services Vertex AI.

Le premier déploiement peut s’effectuer en quelques minutes.

Pré-requis :

La CLI Google Cloud (gcloud)

1. Installation et initialisation du projet

Création d’un environnement virtuel Python (ici à l’aide de uv):

mkdir deploy-with-adk && cd deploy-with-adk
uv venv --python 3.12
source .venv/bin/activate

Initialisation d’un projet d’agent avec ADK :

uv pip install google-adk
adk create personal_assistant

L’arborescence du projet est automatiquement créée :

└── deploy-with-adk
    └── personal_assistant
        ├── __init__.py
        ├── .env
        └── agent.py

2. Création d’un agent

Dans mon fichier agent.py, j’ai créé, pour cet article, un agent tout simple capable de répondre à mes questions tout en se basant sur un datastore dans VertexAI Search contenant différents documents personnels.

from google.adk.agents.llm_agent import Agent
from google.adk.tools import VertexAiSearchTool

root_agent = Agent(
    model='gemini-2.5-flash',
    name='root_agent',
    instruction="Answer questions using Vertex AI Search to find information from internal documents. Always cite sources when available.",
    description="Enterprise document search assistant with Vertex AI Search capabilities",
    tools=[VertexAiSearchTool(data_store_id=DATASTORE_ID)]
)

3. Déploiement

adk deploy agent_engine \
    --project=${PROJECT_ID} \
    --region=${PROJECT_REGION} \
    --staging_bucket=gs://${BUCKET_NAME} \
    --display_name="Personal Assistant" \
    personal_assistant

Cette commande :

construit une image container de votre agent,
la déploie sur Vertex AI Agent Engine,
et génère un endpoint accessible via API ou depuis d’autres agents.

Une fois déployé, votre agent peut être intégré dans des workflows plus complexes.

🚀 Déployer un agent avec un autre framework grâce au SDK Vertex AI

Si ADK intègre simplement le déploiement, Agent Engine est aussi compatible avec de nombreux autres frameworks d’agents IA comme LangChain, LlamaIndex ou CrewAI via la SDK de Vertex AI.

Cette approche permet d’intégrer un agent existant (déjà conçu avec LangChain par exemple) dans l’écosystème Vertex AI pour le monitorer, le scaler et le connecter à d’autres services Google Cloud.

1. Installation et initialisation du projet

Commençons par initialiser Vertex AI avec le projet, la région, et un “staging bucket” (nécessaire pour le packaging de l’agent).

mkdir deploy-with-vertex && cd deploy-with-vertex && touch agent.py

uv venv --python 3.12
source .venv/bin/activate

uv pip install google-cloud-aiplatform[agent_engines,langchain]

2. Création d’un agent

Dans le fichier agent.py, nous allons repartir du même cas d’usage que l’agent précédent, mais cette fois en utilisant LangChain.

Cet agent sera capable de répondre à des questions en interrogeant un datastore Vertex AI Search contenant différents documents personnels.

from vertexai import init, agent_engines
from langchain_retrievers.google_vertex_ai_search import VertexAISearchRetriever
from langchain.tools import Tool

# Init Vertex AI
init(
    project=${PROJECT_ID},
    location=${PROJECT_REGION},
    staging_bucket="gs://${STAGING_BUCKET}",
)

# Create retriever
retriever = VertexAISearchRetriever(data_store_id=${DATASTORE_ID})

# Define search tool
search_tool = Tool(
    name="vertex_search",
    func=lambda query: retriever.get_relevant_documents(query),
    description="Searches your private document store via Vertex AI Search."
)

# System prompt
system_prompt = """
You're an intelligent assistant that can answer questions using internal document search. Use the search tool when necessary.
"""

# Create Langchain Agent
agent = agent_engines.LangchainAgent(
    model="gemini-2.5-flash",
    system_instruction=system_prompt,
    tools=[search_tool],
    model_kwargs={
        "temperature": 0.3,
        "top_p": 0.9,
        "max_output_tokens": 1000,
    },
)

3. Intégration de l’agent dans Vertex AI

La ligne clé suivante permet d’envelopper l’agent LangChain dans une classe compatible avec Vertex AI Agent Engine. C’est cette abstraction qui rend possible son déploiement dans l’infrastructure Vertex AI.

agent = agent_engines.LangchainAgent(...)

Vertex AI fournit également d’autres classes pour intégrer différents frameworks comme par exemple :

agent_engines.LlamaIndexAgent pour LlamaIndex,
agent_engines.CrewAIAgent pour CrewAI.

4. Déploiement

J’ajoute ensuite la méthode ci-dessous pour le déploiement. Plusieurs options sont disponibles pour configurer le déploiement et notamment le paramètre “requirements” pour définir les packages nécessaires à l’agent.

remote_agent = agent_engines.create(
    agent_engine=agent,
    requirements=[
        "google-cloud-aiplatform[agent_engines,langchain]",
        "langchain_community",
    ],
)

print(f"✅ Agent deployed with success.")

Ce code va :

“sérialiser” l’agent
envoyer le code vers le staging bucket,
déployer l’agent sur Vertex AI Agent Engine

Il ne me reste plus qu’à exécuter mon fichier et l’agent sera déployé en quelques minutes

uv run index.py

💬 Interagir avec l’agent déployé

Une fois l’agent déployé sur Vertex AI Agent Engine, il est possible de l’interroger directement depuis le code Python à l’aide du SDK Vertex AI, quelle que soit la méthode de déploiement (ADK ou via le SDK VertexAI).

Les agents déployés via ADK ou via le SDK Vertex AI sont compatibles avec la même API.

Voici un exemple minimaliste d’interaction :

from vertexai import agent_engines

# Get the deployed agent engine
agent_engine = agent_engines.get(${RESOURCE_ID})

# Send a request to the agent
response = agent_engine.query(
    input="Who won the FIFA World Cup in 2018?"
)

# Display the text response
print(response.output_text)

💡 En résumé

Dans cet article, nous avons vu deux manières de déployer un agent sur Vertex AI Agent Engine : le framework ADK, idéal pour un déploiement rapide et standardisé, et le SDK Vertex AI, plus flexible pour intégrer des frameworks comme LangChain et des outils personnalisés.

L’exemple présenté reste volontairement simple, mais il est possible d’aller beaucoup plus loin:

configurer le service account associé à chaque agent,
ajuster les paramètres d’exécution, ou activer le monitoring.

💡 Update 10/11/2025 – Vertex AI Agent Engine Express Mode

Quelques jours après la sortie de cet article, Google a introduit le mode Express pour Vertex AI Agent Engine.

Ce mode permet d’utiliser Agent Engine sans créer de projet Google Cloud, simplement avec un compte Gmail et une clé API depuis Vertex AI Studio.

ℹ️ Depuis le 1er novembre 2025, un nouveau free tier est également disponible pour permettre aux développeurs d’expérimenter Agent Engine gratuitement.

Pour approfondir le sujet :

Documentation Vertex AI Agent Engine
Guide de déploiement ADK
agent-starter-pack: Une collection de modèles d'agents IA prêts à l'emploi, conçus pour Google Cloud.
Google Skills pour monter en compétence sur les produits Google

DuckDB on AWS Lambda: The Easy Way with Layers

Benjamin Bourgeois — Fri, 12 Sep 2025 19:23:30 +0000

A few weeks ago, I faced a recurring task: every week, a batch of TSV files (which is just like a CSV, Comma-Separated Values file, but it uses tabs instead of commas to separate the values) needed to be ingested and loaded into an RDS database. Maintaining a full database for this simple weekly operation felt overkill, and the process itself was time-consuming.

It seemed like the perfect opportunity to explore DuckDB, an in-process analytical database known for its efficiency and simplicity

💡 The idea was to process the TSV files directly in a serverless environment, transform them with SQL queries, and store the results without running a persistent database.

🦆 What is DuckDB

DuckDB is an open-source, in-process analytical database often described as “the SQLite of analytics”. It is optimized specifically for analytical queries and can scan large datasets efficiently.

One of its standout features is the ability to read columnar storage formats like Parquet directly from local files, S3 buckets, or HTTP endpoints. DuckDB scans and aggregates data on the fly without loading entire datasets into memory, which is particularly useful in serverless environments where memory and compute usage directly impact cost.

Now combine that with AWS Lambda : instead of Athena queries, RDS instances, or complex ETL pipelines, DuckDB allows you to run analytical workloads on-demand in a Lambda function, paying only for what you actually use. Existing AWS services like Athena or RDS can address similar needs, but they come with different scaling models and pricing strategies. Athena, for example, charges per scanned byte and introduces query latency, while RDS requires you to maintain an always-on database.

🤯 The Challenge with DuckDB on Lambda

To configure my Lambda, I rely on Terraform to manage the infrastructure. However, I quickly ran into a major issue: DuckDB is a compiled library.

This means you can’t just pip install duckdb locally and upload it through Terraform. If the binary hasn’t been compiled for the Lambda runtime environment, the function will fail to import it. Simply zipping the code is usually not enough, due to ABI incompatibilities and OS differences.

To get around this, I had to set up a Docker container, build DuckDB inside it, copy the resulting files back to my machine, zip them, and then upload everything to Lambda.

This approach works, but it’s far from ideal for small projects or when you just need to get a Lambda running quickly. You're forced to deal with problems like installing Docker and setting up a container build process, which adds significant complexity.

✅ Solution

That’s why I decided to create prebuilt Lambda layers for each architecture, Python version, and DuckDB version, then make them public.

A Lambda layer is a convenient way to package and share dependencies across multiple Lambda functions, without having to include them in every single deployment package. This completely eliminates the need for a local build, so anyone can use DuckDB without repeating the same tedious setup.

These layers are

✅ Pre-compiled for every Lambda-supported Python runtime (3.8 → 3.13).
✅ Supports both architectures (x86_64 and arm64).
✅ Available in all AWS regions.
✅ Easy to attach to your Lambda without increasing your deployment package size.

Adding DuckDB to a Lambda function is as simple as attaching a Lambda layer with its ARN:

aws lambda update-function-configuration \
  --function-name your-function-name \
  --layers LAYER_ARN

Then inside your handler:

import duckdb

def lambda_handler(event, context):
    conn = duckdb.connect(":memory:")
    result = conn.execute("SELECT 'Hello from DuckDB!' AS msg").fetchall()
    return {"statusCode": 200, "body": result[0][0]}

Once the layer is attached, DuckDB is immediately available in your Lambda function, eliminating the need to build it from source or worry about architecture mismatches.

These layers make serverless analytics accessible: tasks that previously required RDS, Athena, or complex ETL pipelines can now be handled entirely within Lambda.

💙 The project is open-source. You can find all layer ARNs and usage instructions on GitHub.

👉🏼 Back to the Initial Problem

The original problem I wanted to solve was quite simple: every week I had to fetch a set of TSV files and import them into a MySQL database hosted on RDS.

With DuckDB, this workflow became surprisingly straightforward. Once the files are downloaded and available locally in the Lambda /tmp directory, DuckDB can both read them directly and push the data into MySQL using its extension system.

Here’s the core of what it looks like:

import duckdb

def handler(event, context):
        # Connect to DuckDB in memory
        con = duckdb.connect(database=':memory:')

        # Install and load the MySQL extension
        con.install_extension("mysql")
        con.load_extension("mysql")

        # Attach to the target MySQL database
        con.execute("""
        ATTACH 'host=... user=... password=... port=... database=...' AS mysql (TYPE mysql);
        """)
    con.execute("USE mysql;")

    # Write directly the TSV into a table
    con.execute("""
        CREATE TABLE users AS
        SELECT * FROM read_csv('/tmp/users.txt', header=true, delim='\\t');
    """)

    # Example query
    result = con.execute("SELECT COUNT(*) FROM users").fetchone()[0]

    return {
        "statusCode": 200,
        "body": f"Users imported: {result}"
    }

Conclusion

Working with DuckDB inside AWS Lambda can feel tricky at first because of the binary and platform compatibility issues. But with prebuilt layers, the whole process becomes much simpler: you can focus on writing your Lambda logic instead of worrying about how to build and package DuckDB.

For my use case, this meant going from a manual Docker build and zip dance to a simple Terraform deployment with a ready-to-use layer. Hopefully, by making these layers public, others can save the same time and frustration.

💙 The project is open-source. You can find all layer ARNs and usage instructions on GitHub.

It also exists for NodeJS, thanks to a great initiative by tobilg, you can find it here.

⭐ Star the repo, give it a try, and do not hesitate to open a PR!

Google Agent Development Kit : Core Concept

Benjamin Bourgeois — Mon, 30 Jun 2025 16:51:26 +0000

Recently, Google announced their Agent Development Kit (ADK), which is an open-source Python (and Java recently) library to help developers build agents.

We’re entering a new phase where AI doesn’t just respond; it can act. These agents can search the web, write and execute code, read documents, call APIs, and perform many other tasks to get things done, often without needing step-by-step instructions.
Since May 20th 2025, the framework is officially stable in Python so I was immediately interested in diving in to understand all the possibilities it offers.

In this post, I’ll walk you through all the core concepts, what it is, and what it offers.

🔍 What is Google Agent Development Kit?

Agent Development Kit is a framework to build, run, and evaluate AI agents. These agents can be simple (answering a question with a tool) or more advanced (planning tasks, calling APIs, interacting with files, or even spawning sub-agents).

💡 Google says it uses the same underlying framework as its internal systems, like Agentspace or those powering Gemini experiences in tools like Gmail or Docs.

ADK is:

Open-source, promoting community collaboration.
Designed for both solo agents and multi-agent systems.
Is able to work seamlessly with Google Cloud services like Vertex AI and Cloud Run, but is also capable of running locally or with other models.

ADK helps us to:

Create agents that use LLMs to plan and reason
Add tools that connect to APIs or run code
Run workflows with multiple agents working together
Deploy our agents locally or in the cloud

🧩 Core Concept and Architecture of ADK

So how does ADK actually work under the hood? It’s built around a few key building blocks.

ADK is built around several key building blocks that enable its powerful capabilities:

🧠 Agent: The fundamental unit designed to perform specific jobs. This includes LlmAgent (driven by LLMs) and various WorkflowAgent types (SequentialAgent, ParallelAgent, LoopAgent), and Custom Agents for maximum flexibility.
🛠️ Tools: Functions or capabilities that extend an agent's abilities, allowing it to interact with external systems (e.g., searching, calculating, API calls, MCP).
📞 Callbacks: Custom code snippets that allow you to insert logic at specific points in an agent's process, useful for logging, monitoring, or modifying behavior.
🧾 Events: Records of everything happening within a session (user messages, agent replies, tool calls), providing a clear historical trace for debugging and evaluation.
💾 State, Session, and Memory: A Session represents an ongoing interaction, managing its short-term State (current context), while Memory provides longer-term recall across sessions.
📁 Artifact Management: A mechanism for agents to manage and store files and data blobs (like generated CSVs or images) associated with a session.
⚙️ Code Execution: A powerful capability allowing agents to dynamically write and run code during their process to solve complex problems or automate tasks.
🧭 Planning: An advanced feature where agents can break down complex goals into a sequence of steps, determining the optimal approach using their tools and reasoning.
🧬 Models: The Large Language Models (LLMs) that LlmAgents rely on for reasoning. ADK is model-agnostic, supporting various providers while being optimized for Gemini and the Google ecosystem.
🏃 Runner: The orchestrator within ADK that manages the flow of events between the user, the agent, and its tools, ensuring everything executes in the correct order.

🚀 Let’s implement our first multi-agent system

For this hands-on part, our goal is to build a smart system that can organize a weekend trip to a city, planning an optimized itinerary to visit the most popular places efficiently.

1️⃣ Step 1: Defining our specialized agents

👤 The `places_finder` Agent

places_finder = LlmAgent(
    name="places_finder",
    model="gemini-2.0-flash",
    description="An agent to find popular places to visit in a city.",
    instruction=(
        "You are a helpful travel researcher. Your task is to find the top 5 most popular or highly-rated tourist attractions in the given city."
        "Use the Google Search tool for this. For each place, provide its exact name and, if possible, its full address or a clear identifier."
        "Return the list of places, clearly separated."
    ),
    tools=[
        google_search
    ]
)

The places_finder is an LlmAgent equipped with the Google Search tool, giving it the ability to browse the web for information.

👤 The `geocode_finder` Agent

Before we can plan a path, we need precise coordinates for our places of interest.
That's where the geocode_finder comes in.
It takes a human-readable address or place name and converts it into a geocode (latitude and longitude) leveraging the MCPToolset for Google Maps to perform its core function.

geocode_finder = LlmAgent(
    name="geocode_finder",
    model="gemini-2.0-flash",
    description="Agent to geocode addresses and place names into coordinates.",
    instruction=(
        "You are a precise geocoding assistant. You will receive an address or a place name."
        "Your only task is to use the provided Google Maps MCP tool to get its exact geographic coordinates (latitude and longitude)."
        "Return ONLY the latitude and longitude, formatted as a string 'latitude,longitude' (e.g., '48.8584,2.2945')."
        "If you cannot find the geocode, return 'ERROR'."
    ),
    tools=[
        MCPToolset(
            connection_params=StdioServerParameters(
                command='npx',
                args=[
                    "-y",
                    "@modelcontextprotocol/server-google-maps",
                ],
                env={
                    "GOOGLE_MAPS_API_KEY": google_maps_api_key
                }
            ),
        )
    ]
)

👤 The `path_planner` Agent

path_planner = LlmAgent(
    name="path_planner",
    model="gemini-2.0-flash",
    description="An agent to optimize the visiting path for a list of geocoded locations.",
    instruction=(
        "You are an expert route optimization specialist. You will receive a list of geocodes (latitude,longitude strings) "
        "representing places to visit in a city. Your goal is to use the Google Maps MCP tool to find the most efficient travel path "
        "to visit all these locations, minimizing travel time and avoiding unnecessary backtracking."
        "Return the optimized list of geocodes in the recommended visiting order, each on a new line. "
        "Also, provide a brief, clear textual description of the optimized route."
    ),
    tools=[
        MCPToolset(
            connection_params=StdioServerParameters(
                command='npx',
                args=[
                    "-y",
                    "@modelcontextprotocol/server-google-maps",
                ],
                env={
                    "GOOGLE_MAPS_API_KEY": google_maps_api_key
                }
            ),
        )
    ]
)

The path_planner is an LlmAgent equipped with the MCPToolset for Google Maps, giving it the power to calculate routes.
This agent's job is to figure out the best route. It's smart enough to understand geographical points and use Google Maps to optimize a visiting path.

👤 The `root_agent`

This is the main agent the user will interact with. Its role is to orchestrate the entire planning process by calling upon the other specialized agents.

root_agent = Agent(
    name="city_trip_planner",
    model="gemini-2.0-flash",
    description="An agent to plan an optimized city visit itinerary.",
    instruction=(
        "You are an experienced travel agent specializing in city tours. "
        "When a user asks to plan a visit in a city, follow these steps meticulously:"
        "1. First, use the `places_finder` tool to get a list of the top popular places in that city."
        "2. For each place found, use the `geocode_agent` tool *one by one* to obtain its geographic coordinates. Handle any places that cannot be geocoded by noting them but continuing with the others."
        "3. Once you have geocodes for all successfully identified places, pass this *list of geocodes* to the `path_planner` tool to get the most optimized visiting route."
        "4. Finally, present the complete, optimized itinerary to the user in a clear and friendly manner. Include the order of places to visit and the route description provided by the path planner. Do not include internal tool outputs in the final user response."
        "If you encounter any issues (e.g., unable to find places or geocode them), inform the user about the problem."
    ),
    tools=[
        agent_tool.AgentTool(agent=path_planner),
        agent_tool.AgentTool(agent=geocode_finder),
        agent_tool.AgentTool(agent=places_finder),
    ]
)

The root_agent is also an LlmAgent acting as our "City Trip Planner" : first find places, then use geocode_agent to get their coordinates, and finally pass those coordinates to path_planner for routing.

Notice the tools list for root_agent: it uses agent_tool.AgentTool to include places_finder, path_planner and geocode_agent as its own tools.
This is an ADK feature, agents can directly call other agents as if they were simple functions, enabling multi-agent hierarchies.

2️⃣ Step 2: Running the agent

The Agent Development Kit can be easily installed following these instructions : https://github.com/google/adk-python

Then, to open the ADK developer interface, simply run the command:

adk web

Once the ADK UI is open, we can start a new conversation. Let's ask our agent team to plan a weekend trip to Nantes.

The ADK UI provides a powerful visual representation of our agents working behind the scenes.
The interaction graph is helpful to understand multi-agent systems.
We’ll see the root_agent delegating tasks, the places_finder researching attractions, the geocode_agent converting addresses to coordinates, and finally, the path_planner optimizing the route.

What's Next?

I hope this first article has provided you with a clearer understanding of what Google ADK is and how you can begin creating your own agents to help with daily tasks. You've seen a concrete example of setting up a multi-agent system, and had an overview of the multitude of tools you can connect to these agents.

In the next article, we'll try to use other tools provided by this framework, explore custom functions, deep dive into MCP, and look into deploying your agents to Google Cloud.

🤖 Using Gemini Code Assist for Code Reviews in My Personal Project

Benjamin Bourgeois — Mon, 28 Apr 2025 11:01:40 +0000

I work solo on a few side projects, and even though I enjoy coding, reviewing my own pull requests isn’t exactly fun (or efficient). I tend to skip reviews, miss obvious bugs, and come back weeks later thinking “what was I thinking?”

So I tried working with a new teammate : Hello Gemini Code Assist 👋🏼

If you haven’t heard of Gemini Code Assist, It is a generative AI coding assistant to help you with tasks across the Software Development Lifecycle and powered by Gemini 2.5. Think of it like a reviewer that gives instant feedback, suggests ready-to-commit code fixes, and even summarizes your pull requests.

Spoiler: It’s like having a helpful teammate who never sleeps ☕

🚀 What Gemini Actually Does on my PR

When I open a PR Gemini jumps in within ~5 minutes. It adds itself as a reviewer (gemini-code-assist[bot]) and I get:

A summary of the PR ;
A list of code comments with suggestions ;
Sometimes even fixes I can commit directly.

I can also talk with it, asking for clarifying questions on the review that it creates, etc.

The available commands are the following :

Feature	Command	What it does
Review code	`/gemini review`	Full review of the current PR
Summarize PR	`/gemini summary`	TL;DR of your PR
Ask something	`@gemini-code-assist`	Ask it anything in a comment
Help	`/gemini help`	List of available commands

I usually trigger a /gemini review just before merging to double-check everything.

📄 1. Pull Request Summary

Right after I open a PR, Gemini write a summary comment to give a quick heads-up. It includes:

A short overview of what’s been changed
Highlights of the major updates or refactors
A mini changelog listing the important modifications

Perfect if you want your team (or future you) to instantly understand what’s going on without digging into every file.

🕵🏼‍♂️ 2. Code Review Summary

A few seconds (or minutes) later, Gemini posts a second comment, this one focuses on what it found during its review. It covers:

A general overview of all detected issues
Severity and potential impact of each issue (from small nitpicks to critical bugs)
Suggested improvements to fix or enhance the code

🔍 3. Code Reviews comments and proposals

For each specific issue spotted, Gemini also leaves inline comments right where the problems are in code. Each detailed review includes:

The priority level of the issue (critical, high, medium, or low)
A clear explanation of what to change (sometimes with examples)
A reference to the style guide rule (either Gemini’s defaults or your custom rules)

💡 Gemini Code Assist is currently in preview and may make mistakes.
You can react with 👍 and 👎 on gemini-code-assist's comments to provide feedback.

🙋🏼 4. Answer questions

You can directly ask Gemini Code Assist questions inside pull request comments!

Just mention it manually, and it will read the surrounding code and answer right in the thread with:

A clear, concise answer based on the code and the context.
Additional insights or clarifications if needed (e.g., explaining a complex change, suggesting alternatives).

This is super useful when you want a second opinion or quick advice without waiting for a human reviewer.

This is a really simple question here 😄

🛠️ Customizing Gemini for Your Project

By default, Gemini Code Assist acts like a well-trained reviewer even without any customization.

Here’s what it looks for when reviewing your pull requests:

Correctness: It checks if your code actually does what it’s supposed to. Gemini looks for logic errors, bad API usage, forgotten edge cases, or even race conditions.
Efficiency: It spots performance issues like unnecessary loops, memory leaks, inefficient data structures, and heavy logging that could slow down your app.
Maintainability: Gemini cares about your future self. It flags messy variable names, overly complex functions, code duplication, missing documentation, inconsistent formatting, and anything that could make your code harder to read or maintain.
Security: It keeps an eye out for common security issues like input validation problems, insecure data storage, missing access controls, or vulnerabilities like CSRF and IDOR.
Miscellaneous: It can also comment on things like testing, scalability, modularity, and error handling/logging.

Guiding Gemini on how to review your code.

Just add a .gemini/ folder at the root of your repo with these two files:

🔧 `config.yaml` — Control what Gemini does

This file controls how much Gemini talks and when.

Example:

have_fun: true
code_review:
  comment_severity_threshold: MEDIUM
  max_review_comments: 10
  pull_request_opened:
    summary: true
    code_review: true

This configuration tells Gemini to:

Only flag issues that are medium severity or higher.
Cap the number of comments to avoid overwhelming you.
Always post a PR summary and code review when a PR is opened.
And most important, to enable fun features such as a poem in the initial pull request summary.

📘 `styleguide.md` — Teach it your rules

You can write your own custom coding rules for Gemini to follow.

For this Go Project, mine’s really simple but you can include stuff like project structure, naming convention, tooling, code style, etc:

- Always return early in functions to reduce nesting.
- Avoid using `panic` outside of `main()` or tests.
- Always check for `err` immediately after a function call.
- Use `log/slog` instead of `fmt.Println`.
- Group standard library imports separately from third-party imports.
- Avoid magic numbers; define them as constants.

It’s not just basic linting — it actually adjusts its review based on what you care about.

You can check a complete example here.

🧵 Final Thoughts

If you’re working solo or on a small team, Gemini Code Assist is a super assistant. It saves time, catches issues, and makes your PRs feel way more professional, even if they’re just for a weekend side project.

I’ll keep using it to double-check my PRs and level up my code reviews (even if it's just me reviewing myself 😅).

If you already use it, let me know what your config looks like or if you’ve found creative ways to use it!

📝 Official docs

Check out the official docs here :

Web3 : Le bilan de Google Cloud sur la blockchain en 2024

Benjamin Bourgeois — Wed, 11 Dec 2024 07:55:31 +0000

Google Cloud continue de renforcer sa présence dans l'écosystème blockchain, avec des innovations technologiques, des partenariats stratégiques, et une volonté affichée de démocratiser le Web3.

Tour d'horizon des initiatives marquantes pour cette année 2024

Un nouveau portail Web3, enrichi et consolidé

En Avril 2024, Google Cloud a lancé un portail dédié au Web3, centralisant outils et ressources pour les développeurs, entreprises et startups.

Ce portail propose une gamme complète d’outils et de services, structurée autour de plusieurs axes majeurs :

L’onglet « Discover » : Tous les produits que Google Cloud et la communauté ont conçus pour les développeurs avec des outils dédiés à l’infrastructure, du data warehousing, de l’analytics pour l’analyse des données blockchain, etc. De nombreux réseaux blockchain sont supportés : Ethereum Mainnet et Goerli, Arbitrum, Avalanche, Cronos, Fantom, etc.
L’onglet « Faucet »: Un espace permettant le déploiement et les tests sur les réseaux Ethereum (Sepolia et Holesky)
L’onglet « Events »: Un espace regroupant tous les événements passés ou futurs autour du Web3 et de ses partenaires
L’onglet « Learn »: Toutes les ressources pour vous former dans ce domaine. Vous pouvez retrouver des tutoriels vidéos tels que “Develop an NFT on Ethereum”, “Using Firebase with Web3Auth” ou encore “Secure Digital Assets with MPC”.
L’onglet « Community »: Des liens vers des communautés et les réseaux supportés par Google Cloud
L’onglet « Startup Program »: Un programme dédié aux startups Web3, proposant deux parcours distincts selon le stade de développement

Cette approche témoigne de la volonté de Google Cloud de démocratiser l’accès aux technologies Web3, même si certains outils restent encore très spécialisés pour le grand public.

SUI : Une collaboration centrée sur l’IA

L’une des collaborations majeures de l’année est celle avec SUI, une blockchain Layer 1 issue des travaux de l’équipe derrière les projets Libra et Diem de Facebook. En partenariat avec Mysten Labs, Google Cloud a travaillé sur plusieurs axes stratégiques :

Analyse des données : l’intégration des données de la blockchain SUI dans BigQuery permettant aux développeurs d’accéder à des outils analytiques avancés pour la création de dApps.
IA et sécurité : grâce à Vertex AI, entrainé sur le langage de programmation de smart-contract MOVE, SUI a développé des outils d’audit et de génération de code basés sur l’intelligence artificielle pour améliorer la sécurité et optimiser le développement.
Amélioration de l’expérience utilisateur : la technologie zkLogin permet de combler certaines lacunes entre les applications traditionnelles (Web2) et décentralisées (Web3). Elle utilise des identifiants OAuth de Google et d’autres plateformes Web2 de confiance pour simplifier l’authentification sur les applications Web3 et les portefeuilles numériques.
Infrastructure : la scalabilité de l’infrastructure Google Cloud garantit la performance du réseau SUI.

Amit Zavery, Vice-Président, General Manager et Responsable des plateformes chez Google Cloud, souligne :

« Nous nous engageons à soutenir l’innovation Web3 grâce à notre infrastructure cloud sécurisée et nos capacités en intelligence artificielle. »

Comme le rappelle également Evan Cheng, CEO et co-fondateur de Mysten Labs :

« La collaboration avec Google Cloud nous aide à propulser le développement d’expériences Web3 sécurisées, évolutives et centrées sur l’utilisateur. »
Ce partenariat illustre parfaitement la synergie entre l’expertise technologique de Google Cloud et l’innovation de SUI.

Une infrastructure RPC renforcée

Google Cloud a étendu ses capacités avec le lancement du service Blockchain Remote Procedure Call (RPC). Ce service offre des fonctionnalités clés :

Compatibilité: Un support pour Ethereum mainnet et testnet
Performance et accessibilité : jusqu’à 100 appels par seconde dans son niveau gratuit.
Interopérabilité : compatible avec le protocole Ethereum JSON-RPC, facilitant son intégration dans des systèmes existants.
Extension future : Google prévoit d’ajouter la prise en charge de nouveaux réseaux blockchain en 2025.

Un service RPC est essentiel pour interagir avec une blockchain. Il permet aux développeurs et aux applications de communiquer avec les nœuds du réseau blockchain en envoyant des requêtes et en recevant des réponses. Grâce à cette couche d’abstraction, les développeurs et les utilisateurs peuvent interagir facilement avec la blockchain sans devoir gérer la complexité technique sous-jacente, comme la synchronisation des nœuds ou le traitement des données brutes.

L’engagement de Google Cloud pour améliorer l’interaction avec les données blockchain a été salué, notamment par Kyle Quintal de 0xArc :

« Les offres RPC de Google Cloud offrent des temps de réponse rapides — exactement ce que vous attendez. »

Blockchain et gaming : GameStack et l’essor du Web3 dans les jeux

L’année 2024 a également vu un rapprochement entre Google Cloud et l’industrie du jeu vidéo via des partenariats comme celui avec Sequence. Cette plateforme tout-en-un pour le développement de jeux Web3 est désormais disponible sur Google Cloud Marketplace, facilitant l’intégration de technologies blockchain dans les jeux vidéo.

Les outils fournis incluent des Unity APIs et des fonctionnalités pour gérer portefeuilles, NFT et transactions. Sequence prend en charge toutes les blockchains EVM, y compris les Layers 1 et 2, ainsi que les Layers 3/App Chains.

Dai Vu, directeur général des programmes Marketplace et ISV GTM chez Google Cloud, a déclaré :

« Amener Sequence sur Google Cloud Marketplace aidera les clients à déployer, gérer et développer rapidement la plateforme de développement de jeux Web3 sur l’infrastructure de Google Cloud. Sequence peut désormais évoluer en toute sécurité et accompagner ses clients dans leur transformation numérique. »

Comme l’a expliqué Michael Sanders, cofondateur de Sequence :

« Nous nous sommes lancés sur Google Cloud Marketplace en tant que fournisseur d’infrastructure pour les jeux Web3, afin d’aider les développeurs à attirer, fidéliser et monétiser les joueurs tout en offrant des expériences de jeu disruptives. »

Un message fort contre la fraude

Google Cloud démontre également son engagement dans la sécurisation de l’écosystème Web3 en adoptant des mesures juridiques inédites. L’entreprise a engagé une action en justice contre un groupe ayant proposé des applications frauduleuses sur la plateforme Google Play pendant plusieurs années. Ces applications, qui promettaient des gains exceptionnels à ceux investissant dans les cryptomonnaies, ont en réalité permis de détourner des sommes considérables.

Pour la première fois, Google a choisi de poursuivre en justice les deux principaux instigateurs de cette fraude, en s’appuyant sur la loi RICO (Racketeer Influenced and Corrupt Organizations), habituellement utilisée dans des affaires de crime organisé. Cette initiative positionne Google comme pionnier parmi les entreprises technologiques dans l’utilisation de ce cadre juridique pour lutter contre les escroqueries.

Comme le souligne Halimah DeLaine Prado, avocat pour Google :

« Rien qu’en 2023, nous avons vu plus d’un milliard de dollars de fraudes et d’escroqueries aux cryptomonnaies aux États-Unis et ce dossier nous permet non seulement d’utiliser nos ressources pour protéger les utilisateurs, mais également de servir en quelque sorte de précédent aux futurs mauvais acteurs dont nous ne pouvons tolérer le comportement. »

La suite en 2025

En 2024, Google Cloud confirme son ambition de devenir un acteur majeur du Web3 en proposant une infrastructure complète et sécurisée. Entre innovations techniques, partenariats stratégiques et engagement contre la fraude, la plateforme pose les jalons d’un écosystème Web3 plus mature et accessible. Les développements à venir, notamment l’extension du support RPC à d’autres réseaux blockchain, laissent présager de nouvelles avancées significatives dans les mois à venir.

Rendez-vous l’année prochaine.

Reflecting on my Hacktoberfest 2024 journey

Benjamin Bourgeois — Tue, 29 Oct 2024 22:01:37 +0000

This is a submission for the 2024 Hacktoberfest Writing challenge: Contributor Experience

This month, I had the pleasure of diving into Hacktoberfest proactively with a few clear goals in mind.

Getting Started with Hacktoberfest 🎉

1️⃣ First, I wanted to discover the world of open source, as I’ve always admired the collaborative nature of these projects.

2️⃣ Secondly, I was motivated to contribute to projects that I personally use or find useful, because I believe in helping to maintain and improve projects that I hope will continue to be available to the community.

3️⃣ Finally, I saw Hacktoberfest as a great technical challenge. Working on real projects helps me learn faster, and solving real problems while getting feedback directly is the best way to improve my skills.

The Projects I Contributed To 🏗️

I chose two projects that intrigued me for different reasons:

Git Town

I initially started contributing to Git-Town by updating the documentation while trying to install it. 😅

Just after I noticed other issues that intrigued me and moved on to more complex tasks, specifically addressing breaking changes. This phase of my contribution was a highlight; I discussed with the project creator and one other maintainer on a way to implement these changes carefully, ensuring they were integrated in a way that minimized disruption to users. This allowed us to rapidly deploy the new release.

After theses changes, I was thrilled when the creator added me to the Git-Town organization on GitHub. This recognition gave me a real sense of achievement and encouraged me to continue contributing to this project.

You can find the project here 💚

Open Food Facts

I came across Open Food Facts while reading a blog post on project to contribute to during Hacktoberfest, and its public benefit and mission immediately resonated with me. It is a public database of food products from around the world, providing information on ingredients, nutrition, and environmental impact to help users make informed choices.

I chose to focus on updating the Node.js SDK by adding wrappers for the latest API endpoints, writing unit tests, improving CI/CD, and working towards automatic releases of new versions. Through this, I hope to support the project’s growth and stability, ensuring it’s reliable for anyone who wishes to use it to create projects that rely on Open Food Facts. There are often very good project ideas in the opensource world 🙂

You can find the project here 💚

Challenges and Learning Moments 🤗

The most challenging part of Hacktoberfest was getting started with each project. Understanding how the project works and integrating my contributions with the existing architecture required time and patience. It is important to minimize breaking changes wherever possible, which is often easier said than done.

Contributing to open source also reminds how to work asynchronously. Each contributor has their own schedule, and learning to adapt to different timelines and communicate effectively has been a valuable experience.

Looking Forward 🙌

My journey into open source was also made possible by my company, Zenika, which encourages us to engage with this ecosystem. Zenika has a dedicated website, oss.zenika.com, to support open-source involvement, and every October, we host events like live streams, meetups, and more to promote participation.

We also have a dedicated Github Organisation that can be useful if you're interested in joining this ecosystem like this repository on how to promote Open Source Projects.

Hacktoberfest has left me with a sense of accomplishment and a desire to continue contributing to open-source. If you’re new to open source, I encourage you to explore the many resources available, from GitHub to community spaces like Discord, where you can connect with other contributors and learn more about active projects.

Open-source work is often done in people’s personal time, so it’s important to be proactive and patient. Maintainers and contributors may not always be immediately available. 🙌

Thank you for taking an interest in open source. Remember, there are likely more tools you use than you think that rely on open-source contributions 😄

Démarrez votre projet Web3 : panorama tech du développement de smart contracts en 2024

Benjamin Bourgeois — Tue, 08 Oct 2024 09:00:00 +0000

L'idée des smart contracts n'est pas nouvelle. Le concept a été théorisé pour la première fois par Nick Szabo, un informaticien et cryptographe, en 1994. Il a imaginé un système de "contrats numériques" qui pourraient s'exécuter automatiquement sans l'intervention d'un tiers de confiance.

Cependant, il a fallu attendre l'avènement de la technologie blockchain pour que les smart contracts deviennent une réalité. La blockchain est un registre distribué et sécurisé qui permet de stocker et de vérifier des transactions de manière transparente. Cette technologie offre un environnement idéal pour l'exécution de smart contracts, car elle garantit la sécurité et l'immuabilité des données.

Ethereum a été la première plateforme à implémenter des smart contracts. Lancée en 2015, elle a permis aux développeurs de créer et de déployer des contrats sur sa blockchain. Cette innovation a déclenché une vague d'intérêt et a conduit à la création de nombreuses autres plateformes et applications décentralisées.

Plusieurs facteurs contribuent à la tendance actuelle :

L'essor des registres distribués : les registres distribués, dont la blockchain est un sous-type, offrent une infrastructure sécurisée et transparente pour l'exécution de smart contracts. Pour simplifier, nous utiliserons le terme "blockchain" par la suite.
La demande croissante de solutions automatisées : Les entreprises et les particuliers recherchent des solutions automatisées pour simplifier les processus et réduire les coûts. Pouvons nous imaginer une solution automatisée de gestion de l’immobilier ?
Les avantages potentiels des smart contracts : Ils peuvent offrir de nombreux avantages, tels que la sécurité, l'efficacité et la réduction des risques.

La tendance est encore à ses débuts, mais elle a le potentiel de révolutionner de nombreux secteurs d'activité.
Dans cet article, nous explorerons l’état de l’art du développement des smart contracts, les langages et outils pour le développement puis les défis et solutions ainsi que les futures tendances en 2024.

TL;DR

En 2024, le développement des smart contracts continue d'évoluer rapidement, notamment grâce à des plateformes comme Ethereum, Binance Smart Chain, Solana, et Polkadot, chacune offrant des caractéristiques uniques en termes de scalabilité (vitesse), de sécurité et de décentralisation (plus d’informations sur ces 3 piliers en regardant le trilemme de la blockchain). Les langages comme Solidity ou Rust dominent le développement, tandis que de nouveaux outils et frameworks simplifient le processus de création et de déploiement. Malgré les défis persistants de sécurité et de scalabilité, les innovations telles que les oracles, l'inter-opérabilité, et les organisations autonomes décentralisées, ou Decentralized Autonomous Organization (DAOs), ouvrent la voie à des applications plus avancées. Le paysage juridique et éthique reste complexe, mais des efforts sont en cours pour créer un cadre réglementaire plus clair, favorisant une adoption responsable et bénéfique des smart contracts.

Choisir la bonne plateforme : une décision stratégique pour la viabilité de votre projet.

Les plateformes permettant l’exécution de smart contracts sont nombreuses et variées, chacune offrant des caractéristiques uniques qui peuvent influencer la manière dont vos applications sont développées et exécutées.

Les blockchains peuvent être envisagées comme des réseaux décentralisés qui hébergent et exécutent des applications de manière sécurisée et transparente. Elles assurent la vérification et la validation des transactions par un consensus distribué, éliminant ainsi le besoin de tiers de confiance. Ces réseaux peuvent être classés principalement en deux types:

Les blockchains publiques sont des réseaux ouverts à tous où chaque utilisateur peut participer en tant que nœud, valider des transactions, et interagir avec le réseau sans restrictions. Elles sont plus décentralisées et transparentes, au prix de coûts de transaction plus élevés et de difficultés de scalabilité
Les blockchains privées sont des réseaux restreints où l'accès est limité à des utilisateurs ou des organisations spécifiques. Ces blockchains sont souvent utilisées dans un cadre d'entreprise ou par des consortiums où la confidentialité des données et le contrôle sur le réseau sont des priorités mais perdent en sécurité et en interopérabilité.

Choisir la bonne blockchain pour développer et déployer des applications décentralisées (dApps) ou des smart contracts est une décision stratégique qui peut avoir un impact significatif sur le succès de votre projet. Pour vous guider dans votre choix, voici une liste (non exhaustive) de points à considérer :

Performance et Scalabilité : Cela comprend la vitesse de traitement des transactions, le débit du réseau, et la capacité à gérer une augmentation de l'utilisation sans compromettre les performances. Par exemple, Solana est réputée pour sa capacité à traiter plusieurs milliers de transactions par seconde, tandis qu'Ethereum est plus lente mais dispose d'une infrastructure bien établie.
Mécanisme de consensus : Tenez compte du mécanisme de consensus d'une blockchain spécifique en relation avec la sécurité, la vitesse et le coût. Par exemple, la preuve de travail (PoW) est gourmande en énergie pour garantir une sécurité maximale, tandis que la preuve d'enjeu (PoS) est plus économe en énergie tout en offrant une meilleure scalabilité. Il convient d'étudier les mécanismes sous tous les angles.
Les langages de programmation : Ils peuvent influencer le choix en fonction des exigences techniques du projet et de la plateforme choisie. Ethereum utilise bytecode qui sera interprété par l’EVM. Solidity est un langage orienté pour les smart contracts qui permet d’être compilé en bytecode. C'est le choix dominant pour la plupart des développeurs de dApps. Tandis que Polkadot : Permet l'utilisation de Rust pour développer des blockchains personnalisées.
La sécurité : c'est un aspect fondamental qui doit être examiné sous différents angles. Il ne s'agit pas seulement du degré de décentralisation, mais aussi de l'historique de sécurité de la blockchain. Une blockchain plus décentralisée est généralement plus résistante aux attaques et plus transparente. Par exemple, Bitcoin et Ethereum sont souvent considérés comme hautement décentralisés. Vérifiez si la plateforme effectue des audits réguliers de sécurité et si elle a une communauté active qui signale et corrige rapidement les vulnérabilités.
L'écosystème et la communauté de développeurs : un écosystème robuste peut accélérer le développement de votre projet. Il peut être important de savoir s'il y a déjà tout un écosystème d'applis et de protocoles sur lesquels s'appuyer pour construire de nouveaux produits. La capacité d'interagir avec d'autres blockchains et applications est cruciale pour certaines applications.
La gouvernance : elle définit comment les décisions concernant la blockchain sont prises. Comprendre le modèle de gouvernance est essentiel pour évaluer comment les mises à jour, les changements de protocole, et les conflits sont gérés.
Le niveau d'adoption : l’adoption par les utilisateurs et les entreprises est un indicateur clé de la maturité et de la viabilité de la blockchain.

De nombreuses plateformes supportent les smart contracts. Ici, nous comparerons les 10 plus populaires, ce qui donnera déjà une bonne idée des structures disponibles.

Pour donner une idée globale de la comparaison suivante, voici un tableau récapitulatif :

Ethereum

Ethereum est une blockchain publique et open-source. Lancée en 2015 par Vitalik Buterin, Ethereum est devenue la plateforme de développement de smart contracts la plus populaire et la plus mature.

Le principal langage de programmation utilisé dans Ethereum est "turing-complet", c'est-à-dire la capacité à gérer tout calcul réalisable par une machine universelle. Son potentiel est donc illimité. Cela permet aux programmeurs de créer des smart contracts sophistiqués, ouvrant ainsi une multitude de possibilités d'application.

Pour pallier certains de ses inconvénients, Ethereum s'appuie de plus en plus sur des solutions appelées “Layer 2”. Ces couches supplémentaires sont conçues pour améliorer la scalabilité et réduire les frais de transaction en traitant une partie des calculs en dehors de la chaîne principale.

Avantages:

Les smart contracts ne sont pas limités à de simples transactions
Sécurité éprouvée
Décentralisation
Large communauté de développeurs et d'utilisateurs
Large éventail d'outils et de ressources disponibles
Grande variété de dApps déjà déployées

Inconvénients:

Frais de transaction élevés, surtout pour les transactions complexes
Scalabilité limitée
Volume d'utilisation élevé, peut entraîner une congestion et ralentir la vitesse des transactions

Mécanisme de consensus:

Proof-of-Stake (PoS)

Langage de développement:

Les principaux langages de programmation utilisés sont Solidity et Vyper. Les smart-contracts doivent d'abord être compilés en Bytecode. C'est ce Bytecode qui permet à la Machine Virtuelle Ethereum (EVM) d'exécuter le contrat sur la blockchain.

Ethereum + Layer 2

Ethereum reste la blockchain de référence pour le développement de smart contracts, mais ses limitations en termes de scalabilité et de frais de transaction ont conduit au développement de solutions Layer 2. Les Layer 2 sont des protocoles construits sur le dessus d'une blockchain principale (Layer 1) pour réduire la congestion et améliorer l'efficacité des transactions. En déplaçant une partie du processus de transaction hors de la chaîne principale, les Layers 2 permettent de traiter un volume plus élevé de transactions à moindre coût. On peut donc les voir comme des "extensions" du réseau Ethereum.

Avantages:

Réduction des frais de transaction en déchargeant une partie des transactions
Amélioration de la scalabilité
Sécurité inhérente à Ethereum

Inconvénients:

Adoption progressive
Fragmentation: Plusieurs solutions Layer 2 existent (comme Optimistic Rollups et ZK-Rollups), ce qui peut fragmenter l'écosystème et créer des silos.
Complexité supplémentaire: L'intégration de solutions Layer 2 ajoute une couche de complexité pour les développeurs et les utilisateurs, notamment en termes de transfert de fonds entre les layers.

Binance Smart Chain (BSC)

Binance Smart Chain (BSC) est une blockchain privée compatible avec la EVM (Ethereum Virtual Machine) d'Ethereum. Lancée en 2020 par Binance, BSC offre une alternative à Ethereum avec des frais de transaction plus bas et une vitesse de transaction plus élevée.

Avantages:

Faible coût de transaction
Vitesse de transaction élevée
Large adoption par les utilisateurs de Binance
Compatibilité avec la EVM d'Ethereum
Intégration avec tout l’écosystème Binance

Inconvénients:

Centralisation
Réseau dépendant de Binance
Écosystème moins développé qu'Ethereum
Moins de dApps disponibles

Mécanisme de consensus:

PoSA : un hybride entre la Proof-of-Stake (PoS) et la Proof-of-Authority (PoA). Le Proof-of-Staked Authority (PoSA) est un mécanisme de consensus hybride qui combine la Proof-of-Stake (PoS) et la Proof-of-Authority (PoA), où un ensemble de validateurs est sélectionné en fonction de la quantité de tokens qu'ils stakent (PoS) et de leur réputation ou autorité (PoA).

Langage de développement:

Solidity

Solana

Solana est une blockchain publique et open-source qui se concentre sur la vitesse de transaction et la scalabilité. Lancée en 2020 par Anatoly Yakovenko, Solana utilise une architecture innovante, une combinaison entre le Proof-of-History et le Proof-of-Stake.

Le Proof of History (PoH) fournit des horodatages vérifiables pour ordonner les transactions, et lorsqu'il est utilisé avec le Proof-of-Stake, il permet d'atteindre des vitesses de transaction très élevées, plusieurs milliers par seconde.

Avantages:

Architecture innovante pour la scalabilité et économe en énergie
Vitesse de transaction très élevée
Faible coût de transaction
Les smart contracts sont écrit en Rust, ce qui garantit une sécurité élevée.
Les smart contracts peuvent être traités de manière parallèle.

Inconvénients:

Moins décentralisée que d'autres blockchains car les nœuds validateurs demandent beaucoup de matériel
Langage de programmation “bas niveau” ce qui est plus difficile à appréhender
Plateforme relativement nouvelle
Moins de ressources et d'outils disponibles
Le réseau principal (mainnet) est toujours déclaré en bêta

Mécanisme de consensus:

Combinaison entre le Proof-of-History et le Proof-of-Stake

Langage de développement:

Rust

Avalanche

Avalanche est une blockchain publique et open-source. Lancée en 2020 par Emin Gün Sirer, Avalanche utilise un mécanisme de consensus unique conçu pour répondre à des normes de sécurité élevées et résister aux attaques.

Le réseau permet la création de sous-réseaux et de blockchains personnalisées.

Avantages:

Temps de transaction inférieur à la seconde
Architecture unique pour la scalabilité et la sécurité, possibilité de brancher son réseau privé tout en conservant la sécurité des chaînes supérieures.
Possibilité d’avoir des sous-réseaux, avec des règles et des fonctionnalités spécifiques adaptées aux besoins.
Interopérabilité entre différentes blockchains
Compatible avec la Machine Virtuelle Ethereum (EVM)

Inconvénients:

Moins de ressources et d'outils disponibles
Réseau relativement complexe avec une architecture unique, utilisant plusieurs blockchains (X-Chain, C-Chain et P-Chain)
Le jeton natif d'Avalanche, AVAX, offre une liquidité limitée

Mécanisme de consensus:

Avalanche

Langage de développement:

Solidity
C++
Rust

D’autres plateformes pour développer des smart-contracts. Celles-ci sont moins courantes mais méritent d’y jeter un œil : Cardano, Polkadot, Near ou encore Tezos.

Le langage de développement, essentiel pour la stabilité et la longévité du projet

Après avoir examiné les différentes plateformes de développement de smart contracts, il est important de s'intéresser aux langages de programmation qui leur sont associés.

Le choix du langage de programmation est tout aussi important car il impacte la facilité de développement, la maintenabilité du code et la sécurité du contrat et des applications.

Il existe une multitude de langages de programmation pour smart contracts, chacun avec ses propres avantages et inconvénients. Certains langages sont plus populaires que d'autres, comme Solidity pour Ethereum ou Rust pour Solana. Il est important de choisir un langage qui correspond à vos besoins spécifiques.

Voici quelques points à prendre en compte lors du choix d'un langage de programmation pour smart contracts:

Les fonctionnalités disponibles: Le langage choisi doit pouvoir répondre aux besoins de votre application.
La syntaxe: Le langage doit être facile à apprendre et à utiliser.
La sécurité: Le langage doit être sécurisé et permettre de développer des contrats robustes.
La communauté de développeurs: Une communauté active de développeurs peut aider à trouver des réponses à vos questions et à résoudre les problèmes rencontrés

Nous allons maintenant discuter des principaux langages de programmation dans ce domaine.

Solidity

Langage de programmation de haut niveau orienté objet pour les smart contracts sur la blockchain Ethereum et compatible avec la plupart des plateformes EVM (Ethereum Virtual Machine). C’est le langage de programmation le plus répandu pour développer des smart-contracts.

Blockchains: Ethereum, Binance Smart Chain, Polygon, Avalanche, Fantom, et d’autres

Avantages:

Large communauté de développeurs et d'utilisateurs (plus de 200 000 développeurs actifs).
Large éventail d'outils et de ressources disponibles (IDE, frameworks, bibliothèques, tutoriels).
Bien documenté et facile à apprendre (syntaxe proche du C++ et du JavaScript).
Large adoption par les plateformes et les projets DeFi.

Inconvénients:

Pas conçu pour la sécurité formelle (risques de bugs et de vulnérabilités).
Manque de fonctionnalités avancées (gestion de la mémoire, typage générique).
Sujet aux vulnérabilités de sécurité (attaques par reentrancy, overflow, etc.).

pragma solidity ^0.8.0;

contract SimpleContract {
    uint256 public storedData;

    event ValueSet(uint256 newValue);

    function set(uint256 newValue) public {
        storedData = newValue;
        emit ValueSet(newValue);
    }

    function get() public view returns (uint256) {
        return storedData;
    }
}

Rust

Rust est un langage de programmation moderne. Il est apprécié pour sa sécurité de la mémoire, ses performances et sa concurrence. Des blockchains comme Solana l’ont adopté pour l’écriture de smart-contract.

Blockchains: Solana, Near, Polkadot, etc.

Avantages:

Vitesse et performance élevées.
Conçu pour éviter les erreurs de programmation telles que les accès mémoire invalides
Convient aux applications complexes
Langage stable et mature.

Inconvénients:

Courbe d'apprentissage plus forte que Solidity.
Moins de ressources et d'outils disponibles.
Communauté de développeurs plus petite.

Vous pouvez trouver différents projets blockchain utilisant Rust sur ce repo : https://github.com/rust-in-blockchain/awesome-blockchain-rust

#![no_std]
#![feature(alloc_error_handler)]

use ink_lang as ink;

#[ink::contract]
mod simple_contract {
    use alloc::string::String;

    #[ink(storage)]
    pub struct SimpleContract {
        value: String,
    }

    impl SimpleContract {
        #[ink(constructor)]
        pub fn new(initial_value: String) -> Self {
            Self { value: initial_value }
        }

        #[ink(message)]
        pub fn get(&self) -> String {
            self.value.clone()
        }

        #[ink(message)]
        pub fn set(&mut self, new_value: String) {
            self.value = new_value;
        }
    }
}

C++

Développé par Bjarne Stroustrup au début des années 1980, le C++ est un langage de programmation de haut niveau. C'est le sixième langage de programmation le plus populaire.

Blockchain: EOS, Ripple, WAX

Avantages:

Langage performant et flexible
Convient aux applications complexes
Sa syntaxe est bien connue des développeurs

Inconvénients:

Supporté par quelques blockchains seulement
Le code écrit en C++ n'est pas aussi concis que Solidity

class SimpleContract {
    public:
      // Constructor to initialize the value (optional)
      explicit SimpleContract(uint256 initValue = 0) : value(initValue) {}

      void setValue(uint256 newValue) {
        // Access storage and update the value (implementation depends on the platform)
        value = newValue;
      }

      uint256 getValue() const {
        // Access storage and retrieve the value (implementation depends on the platform)
        return value;
      }

    private:
      uint256 value;
};

Selon les plateformes de développement, d’autres langages de programmation existent mais avec des fonctionnalités moins avancées ou des communautés plus petites (Vyper, Michelson, Yul, …)

Les environnements de développement (frameworks, IDEs, …)

Le développement de smart-contracts implique l'utilisation d'une variété d'outils pour simplifier le processus de création, de déploiement et de gestion des contrats.

Ces outils peuvent être classés en différentes catégories :

Les frameworks offrent des structures et des bibliothèques préexistantes pour faciliter le développement de smart contracts. Ils incluent des fonctionnalités pour le déploiement, la gestion des comptes, l'interaction avec la blockchain, la gestion des erreurs et la sécurité.

Ils peuvent être accompagnés de CLIs, fournis par les plateformes telles que NEAR, Solana ou Polkadot, et apportent une manière native de déployer les smart contracts sur leur plateforme.

Frameworks populaires:

Hardhat: Un framework modulaire pour le développement de smart contracts Ethereum. Il offre une flexibilité et une personnalisation pour s'adapter aux besoins spécifiques des projets.
Anchor: Similaire à Truffle ou Hardhat mais pour Solana. Anchor permet de construire des programmes rapidement parce qu'il apporte de nombreuses fonctions prêtes à l’emploi.

Hardhat et Anchor sont les deux frameworks largement populaires sur le marché des smart-contracts, bien que d’autres initiatives existent comme Brownie qui essaie de tirer parti de la simplicité et de la puissance de Python. Auparavant, d’autres frameworks tels que Truffle ou Ganache existaient mais ils sont maintenant en “deprecated” au profit de Hardhat.

Les IDEs jouent un rôle essentiel dans la conception et permettent de réduire les erreurs, d'accélérer le développement, et d'améliorer la qualité du code.

Remix IDE est probablement l'outil le plus connu pour démarrer dans l'écosystème Ethereum et EVM-compatible. Cet IDE en ligne permet d’écrire, compiler et déployer des smart contracts en Solidity, tout en offrant des outils d’analyse, de débogage, et même de simulation de transactions sur la blockchain.

Sinon, un IDE classique comme Visual Studio Code, bien qu'universel et utilisé pour un large éventail de langages, est souvent favorisé par les développeurs blockchain grâce à ses nombreuses extensions qui transforment cet éditeur en un environnement pour le développement d'applications Web3, tout en permettant une intégration avec des outils de déploiement et de tests automatisés.

Les outils d'analyse pour explorer la blockchain qui permettent de visualiser et d'analyser les transactions et les données des smart contracts sur la blockchain. Ils peuvent fournir des informations sur l'état des contrats, les interactions des utilisateurs, etc.

Exemples populaires, bien qu’en général chaque plateforme (Blockchain et Layer 2) a son propre lot d’outils d’analyse :

Etherscan (https://etherscan.io) : Un explorateur de blocs populaire pour la blockchain Ethereum. Il permet de visualiser les transactions, les contrats, les adresses de portefeuille.
Blockchair (https://blockchair.com/fr): Un explorateur de blocs multi-chaînes qui prend en charge la recherche et l'analyse des transactions et des contrats sur différentes blockchains.

Les tendances en 2024

Le domaine du développement de smart contracts évolue rapidement avec l'émergence de nouvelles tendances et applications prometteuses, et notamment :

Oracles: Les oracles sont des ponts entre le monde réel et les blockchains, fournissant aux smart contracts des flux de données externes afin d'accéder et d'interagir avec des données et des événements du monde réel. Cela ouvre de nouveaux cas d'utilisation dans des domaines tels que la finance décentralisée (DeFi), la gestion de la chaîne d'approvisionnement, etc
Interopérabilité : L'interopérabilité permettrait à différentes blockchains de communiquer et d’effectuer des transactions les unes avec les autres de manière transparente, ce qui ouvre de nouvelles possibilités de collaboration. Les projets et les protocoles axés sur l'interopérabilité, tels que Polkadot ouvrent la voie à un écosystème de blockchain plus interconnecté et interopérable.
Organisation autonome décentralisée (DAO): Les DAO sont des organisations gérées par des smart contracts, permettant une prise de décision et une gouvernance décentralisées, facilitant la gestion d'entreprises, de communautés et de projets collaboratifs.

Conclusion

Le développement de smart contracts est un domaine avec une communauté de développeurs très active, de nouveaux outils et leurs améliorations apparaissent régulièrement.

En combinant l'immuabilité et la transparence de la blockchain avec l'automatisation et la programmabilité des contrats, les smart contracts ont le potentiel de transformer des industries entières et de créer de nouveaux paradigmes pour la collaboration et la gouvernance.

Malgré les défis auxquels ils sont confrontés, tels que la sécurité, la scalabilité et l'interopérabilité, des solutions prometteuses et des initiatives émergent continuellement pour offrir des moyens de surmonter ces obstacles et de garantir un avenir stable et sécurisé pour les smart contracts.

En parallèle, il est important de considérer les implications juridiques et éthiques de cette technologie. Des cadres juridiques clairs, une sensibilisation accrue et un dialogue constructif entre les développeurs, les utilisateurs et les décideurs politiques seront essentiels pour garantir une adoption responsable et bénéfique des smart contracts. Il est crucial de se rappeler que cette technologie est un outil puissant qui peut être utilisé pour le bien ou pour le mal. Il est de notre responsabilité collective de veiller à ce qu'ils soient développés et utilisés de manière responsable, éthique et inclusive, afin qu'ils puissent contribuer à un monde plus juste, transparent et efficient.

Rendez-vous en 2025 pour faire un nouveau bilan.

Interacting with Solana in Go: A Beginner's Guide

Benjamin Bourgeois — Wed, 27 Mar 2024 08:50:14 +0000

Solana is a high-performance blockchain platform gaining traction for its scalability and developer experience. This blog post dives into interacting with Solana using Go. We'll explore the basic functionalities like creating a wallet, importing existing one, fetching account balance, and transferring SOL tokens.

History

Solana, founded in 2020 by Anatoly Yakovenko, is a high-performance blockchain that has rapidly gained popularity within the blockchain community. Its architecture, designed to deliver exceptional speed provides scalability and low transaction costs. The core innovation lies in the unique combination of Proof of History and Proof of Stake, allowing the network to achieve consensus quickly and efficiently. The ability to handle thousands of transactions per second, coupled with its developer-friendly environment, makes it an attractive choice for those looking to build decentralized applications at scale.

On the other hand, the selection of a programming language for DApp development necessitates careful consideration of factors such as platform compatibility, developer community engagement, security features, performance, and interoperability. Various languages, including JavaScript, Rust, and Go, can be considered in this context.

Golang stands out as an optimal programming language for building decentralized applications (DApps) on the Solana blockchain. Go's strong support for concurrency aligns perfectly with Solana's design principles, allowing developers to take full advantage of the Solana’s fast transaction processing and scalability.

Prerequisites:

Basic understanding of blockchain
Basic understanding of Golang and a Go development environment
Familiarity with Solana concepts

Choosing a Golang library for Solana:

As of now there is no official library to support interaction with Solana in Go, but there is popular community librairies such as :

gagliardetto/solana-go (https://github.com/gagliardetto/solana-go) This library offers a user-friendly API for interacting with Solana's JSON RPC and WebSocket interfaces.
blocto/solana-go-sdk (https://github.com/blocto/solana-go-sdk) This is a comprehensive SDK for Solana development in Golang. It offers a wide range of functionalities.

In this article, we’ll use the most popular package : gagliardetto/solana-go

Creating a wallet

Let's start by creating a new Solana wallet. We'll use the solana.NewRandomPrivateKey function to generate a new keypair:

package main

import (
    "fmt"

    "github.com/gagliardetto/solana-go"
)

func main() {
    // Generate a new random keypair
    privateKey, err := solana.NewRandomPrivateKey()
    if err != nil {
        panic(err)
    }

    // Get the public key from the private key
    publicKey := privateKey.PublicKey()

    // Print the public and private keys (**keep private key secure!**)
    fmt.Println("Public Key:", publicKey)
    fmt.Println("Private Key:", privateKey)
}

Running this code gives the following:

Importing an existing wallet

You might have to create a new wallet, but most of the time you will most likely import an existing one. To use an existing wallet, you'll need its private key in base58 format.
Here's an example using solana.PrivateKeyFromBase58:

package main

import "github.com/gagliardetto/solana-go"

func main() {
    // Replace with your actual private key in base58 format
    privateKeyString := ".........."

    // Parse the private key from base58
    privateKey, err := solana.PrivateKeyFromBase58(privateKeyString)
    if err != nil {
        panic(err)
    }

    // Get the public key from the private key
    publicKey := privateKey.PublicKey()

    // Print the public and private keys
    println("Public Key:", publicKey.String())
}

Running this code gives the following output:

Request airdrop and fetching wallet balance

For development and testing purposes, you might need test accounts with some SOL tokens to interact with the network. You could use an airdrop to get Solana token on the Devnet and Testnet. This can help you test your application's functionality.

It can be subject to rate limits when there is a high number of airdrops.

We can use the GetBalance method to fetch the balance of an account (wallet):

package main

import (
    "context"
    "fmt"
    "math/big"
    "time"

    "github.com/gagliardetto/solana-go"
    "github.com/gagliardetto/solana-go/rpc"
)

func main() {

    // Create a new account
    account := solana.NewWallet()
    fmt.Println("account private key:", account.PrivateKey)
    fmt.Println("account public key:", account.PublicKey())

    // Create a new RPC client on the DevNet
    rpcClient := rpc.New(rpc.DevNet_RPC)

    // Airdrop 1 SOL to the new account:
    out, err := rpcClient.RequestAirdrop(
        context.TODO(),
        account.PublicKey(),
        // 1 sol = 1000000000 lamports
        solana.LAMPORTS_PER_SOL*1,
        rpc.CommitmentFinalized,
    )

    if err != nil {
        panic(err)
    }

    fmt.Println("airdrop transaction signature:", out)
    time.Sleep(time.Second * 1)

    // Get the balance of the account
    balance, err := rpcClient.GetBalance(
        context.TODO(),
        account.PublicKey(),
        rpc.CommitmentFinalized,
    )

    if err != nil {
        panic(err)
    }

    var lamportsOnAccount = new(big.Float).SetUint64(uint64(balance.Value))
    var solBalance = new(big.Float).Quo(lamportsOnAccount, new(big.Float).SetUint64(solana.LAMPORTS_PER_SOL))

    fmt.Println("Wallet Balance:", solBalance, "SOL")
}

Running this code gives the following output:

Transfer Solana to another wallet

Transfers involve creating and sending a transaction. Here's a simple example with the wallet we requested airdrop on just before:

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/gagliardetto/solana-go"
    "github.com/gagliardetto/solana-go/programs/system"
    "github.com/gagliardetto/solana-go/rpc"
    confirm "github.com/gagliardetto/solana-go/rpc/sendAndConfirmTransaction"
    "github.com/gagliardetto/solana-go/rpc/ws"
    "github.com/gagliardetto/solana-go/text"
)

func main() {
    // Create a new RPC client on the DevNet
    rpcClient := rpc.New(rpc.DevNet_RPC)

    // Create a new WS client (used for confirming transactions)
    wsClient, err := ws.Connect(context.Background(), rpc.DevNet_WS)
    if err != nil {
        panic(err)
    }

    // Load the account that you will send funds FROM
    accountFrom, err := solana.PrivateKeyFromBase58("..........")
    if err != nil {
        panic(err)
    }
    fmt.Println("accountFrom public key:", accountFrom.PublicKey())

    // The public key of the account that you will send sol TO:
    accountTo := solana.NewWallet()
    fmt.Println("accountTo public key:", accountTo)

    // Get the recent blockhash:
    recent, err := rpcClient.GetRecentBlockhash(context.TODO(), rpc.CommitmentFinalized)
    if err != nil {
        panic(err)
    }

    tx, err := solana.NewTransaction(
        []solana.Instruction{
            system.NewTransferInstruction(
                // 1 sol = 1000000000 lamports
                1e6, // 0.001 SOL,
                accountFrom.PublicKey(),
                accountTo.PublicKey(),
            ).Build(),
        },
        recent.Value.Blockhash,
        solana.TransactionPayer(accountFrom.PublicKey()),
    )
    if err != nil {
        panic(err)
    }

    _, err = tx.Sign(
        func(key solana.PublicKey) *solana.PrivateKey {
            if accountFrom.PublicKey().Equals(key) {
                return &accountFrom
            }
            return nil
        },
    )
    if err != nil {
        panic(fmt.Errorf("unable to sign transaction: %w", err))
    }

    // Pretty print the transaction:
    tx.EncodeTree(text.NewTreeEncoder(os.Stdout, "Transfer SOL"))

    // Send transaction, and wait for confirmation:
    sig, err := confirm.SendAndConfirmTransaction(
        context.TODO(),
        rpcClient,
        wsClient,
        tx,
    )
    if err != nil {
        panic(err)
    }
    fmt.Println("Transaction confirmed:", sig)
}

Running this code gives the following output:

Conclusion

In this blog post, we've explored the basics of interacting with Solana using Golang.

This is just the first step on Solana development with Golang. The chosen library offers a wider range of functionalities beyond what we covered here. Remember, the Solana ecosystem is constantly evolving. Stay updated with the best practices to ensure your dApps remain robust and efficient.

Developing a NodeJS Wrapper for Snowflake SDK (Pagination included)

Benjamin Bourgeois — Mon, 05 Jun 2023 14:14:58 +0000

In recent years, Snowflake has gained popularity as a cloud-based data warehousing solution due to its ability to handle large amounts of data. Unlike traditional databases, Snowflake separates storage and compute, allowing users to scale each independently.

⬇️ In this article, I'll propose a simple wrapper to interact with the Snowflake SDK using NodeJS.

Prerequisites

Before using Snowflake, there are a few prerequisites that you need.

Configuring Access to the Snowflake API: To access Snowflake from NodeJS, you will need to configure access to the Snowflake API. This involves creating an account, generating API keys, and configuring network policies.
Installing Dependencies: You will need to install the Snowflake NodeJS SDK and any other required dependencies..

⌨️ npm i snowflake-sdk && npm i -D @types/snowflake-sdk

Interact with Snowflake

The Snowflake SDK provides a set of APIs for interacting with Snowflake, including APIs for connecting to Snowflake, executing queries, and performing other database operations.

const snowflake = require('snowflake-sdk');

// Create a connection to Snowflake
const connection = snowflake.createConnection({
  account: '<your_account_name>',
  username: '<your_username>',
  password: '<your_password>',
  region: '<your_region>'
});

connection.connect((err, conn) => {
  if (err) {
    console.error('Error connecting to Snowflake:', err);
    return;
  }

  // Execute a query
  conn.execute({
    sqlText: 'SELECT * FROM my_table',
    complete: (err, stmt, rows) => {
      if (err) {
        console.error('Error executing query:', err);
        return;
      }

      console.log('Query results:', rows);

      // Destroy connection
      conn.destroy(() => {
        console.log('Connection closed.');
      });
    }
  });
});

In this example, we create a connection to Snowflake using the createConnection method and execute a simple SQL query using the execute method. The results of the query are logged to the console, and the connection is closed using the destroy method.

Building a wrapper with pagination

Configuration

👉 First, we define an abstract class called SnowflakeServiceAbstract. This class has two main properties: snowflakeEnvironment and snowflakeConfig both contain information about the Snowflake account, such as the account name, username, password, role, warehouse, database, and schema. This information is necessary to establish a connection to the Snowflake account.

export abstract class SnowflakeServiceAbstract {
    protected abstract logger: Logger;

    protected snowflakeEnvironment: snowflake.ConnectionOptions;
    protected snowflakeConfig: snowflake.ConfigureOptions;

    protected constructor() {
        this.snowflakeConfig = {
            insecureConnect: process.env.SNOWFLAKE_INSECURECONNECT,
            ocspFailOpen: process.env.SNOWFLAKE_OCSP,
            logLevel: process.env.SNOWFLAKE_LOGLEVEL,
        };
        this.snowflakeEnvironment = {
            authenticator: "SNOWFLAKE",
            account: process.env.SNOWFLAKE_ACCOUNT,
            password: process.env.SNOWFLAKE_PASSWORD,
            username: process.env.SNOWFLAKE_USERNAME,
            role: process.env.SNOWFLAKE_ROLE,
            warehouse: process.env.SNOWFLAKE_WAREHOUSE,
            database: process.env.SNOWFLAKE_DATABASE,
            schema: process.env.SNOWFLAKE_SCHEMA,
        }
    }
}

Managing Snowflake connection

👉 Then, we'll add 3 methods to manage our Snowflake connection.

The first method, connectSnowflake, establishes a connection to the Snowflake account using the configuration options and environment variables that were set in the constructor. This method returns a promise that resolves to the connection object if successful, or rejects with an error if unsuccessful.

The second method, disconnectSnowflake, disconnects from Snowflake. It provides a way to cleanly disconnect from a Snowflake database connection that was established.

The third method, cancelStatementSnowflake, cancels a Snowflake statement. It is useful when you want to cancel a query or operation taking too long to execute or because it is blocking other queries.

export abstract class SnowflakeServiceAbstract {
    protected abstract logger: Logger;

    protected snowflakeEnvironment: snowflake.ConnectionOptions;
    protected snowflakeConfig: snowflake.ConfigureOptions;

    protected constructor() {
        this.snowflakeConfig = {
            insecureConnect: process.env.SNOWFLAKE_INSECURECONNECT,
            ocspFailOpen: process.env.SNOWFLAKE_OCSP,
            logLevel: process.env.SNOWFLAKE_LOGLEVEL,
        };
        this.snowflakeEnvironment = {
            authenticator: "SNOWFLAKE",
            account: process.env.SNOWFLAKE_ACCOUNT,
            password: process.env.SNOWFLAKE_PASSWORD,
            username: process.env.SNOWFLAKE_USERNAME,
            role: process.env.SNOWFLAKE_ROLE,
            warehouse: process.env.SNOWFLAKE_WAREHOUSE,
            database: process.env.SNOWFLAKE_DATABASE,
            schema: process.env.SNOWFLAKE_SCHEMA,
        }
    }

    private connectSnowflake = async (): Promise <any> =>
        new Promise((resolve: any, reject: any) => {
            try {
                snowflake.configure(this.snowflakeConfig);
                const connection: snowflake.Connection = snowflake.createConnection(
                    this.snowflakeEnvironment,
                );

                if (connection) {
                    connection.connect(
                        (err: snowflake.SnowflakeError, conn: snowflake.Connection) => {
                            if (err) {
                                reject(err);
                            } else {
                                this.logger.log(`Connected Snowflake Id: ${conn.getId()}`);
                                resolve(conn);
                            }
                        },
                    );
                }
            } catch (err) {
                reject(err);
            }
        });

    private disconnectSnowflake = async (connection: snowflake.Connection) =>
        new Promise((resolve: any, reject: any) => {
            try {
                connection.destroy((err: err: snowflake.SnowflakeError, _conn: snowflake.Connection) => {
                    if (err) {
                        this.logger.error('Unable to disconnect Snowflake: ' + err.message);
                        reject(err);
                    } else {
                        this.logger.log(`Disconnected Snowflake Id: ${connection.getId()}`);
                        resolve();
                    }
                });
            } catch (err) {
                reject(err);
            }
        });

    private cancelStatementSnowflake = async (statement: snowflake.Statement) =>
        new Promise((resolve: any, reject: any) => {
            try {
                statement.cancel((err: snowflake.SnowflakeError, _stmt: snowflake.Statement) => {
                    if (err) {
                        this.logger.error('Error while cancel statement ' + err.message);
                        reject(err);
                    } else {
                        this.logger.log('Successfully aborted statement');
                        resolve();
                    }
                });
            } catch (err) {
                reject(err);
            }
        });
}

Executing queries

👉 Finally, we add a final method which will be called when we want to execute a query and get the result. It takes in a SnowflakeQueryInterface object as an argument which contains the query to execute, any query parameters (binds), and pagination information.

The SnowflakeResultInterface type defines the structure of the result returned by the query.

The method first connects to the Snowflake database using the connectSnowflake method then executes the query passing in the SQL text, bind parameters, and other options like streaming results. The complete callback function is invoked when the query execution is complete.

It performs pagination on the result set, based on the startIndex and count properties. If startIndex is not provided, it defaults to 0. If count is not provided, it returns the first 1000 rows.

The error event is triggered if there is any error while consuming the rows. In that case, the method logs an error message, cancels the statement, disconnects and rejects with the error.

The end event is triggered when all the rows have been consumed.

Final class and interfaces

export interface SnowflakeQueryInterface {
  readonly query: string;
  readonly binds?: snowflake.Binds;
  readonly startIndex?: number;
  readonly count?: number;
}

export interface SnowflakeResultInterface {
  readonly total: number;
  readonly pageSize: number;
  readonly hasNextPage: boolean;
  readonly results: any[];
}

import * as snowflake from 'snowflake-sdk';

export abstract class SnowflakeServiceAbstract {
  protected abstract logger: Logger;

  protected snowflakeEnvironment: snowflake.ConnectionOptions;
  protected snowflakeConfig: snowflake.ConfigureOptions;

  protected constructor() {
    this.snowflakeConfig = {
      insecureConnect: JSON.parse(process.env.SNOWFLAKE_INSECURECONNECT),
      ocspFailOpen: JSON.parse(process.env.SNOWFLAKE_OCSP),
      logLevel: JSON.parse(process.env.SNOWFLAKE_LOGLEVEL),
    };
    this.snowflakeEnvironment = {
      authenticator: 'SNOWFLAKE',
      account: process.env.SNOWFLAKE_ACCOUNT,
      password: process.env.SNOWFLAKE_PASSWORD,
      username: process.env.SNOWFLAKE_USERNAME,
      role: process.env.SNOWFLAKE_ROLE,
      warehouse: process.env.SNOWFLAKE_WAREHOUSE,
      database: process.env.SNOWFLAKE_DATABASE,
      schema: process.env.SNOWFLAKE_SCHEMA,
    };
  }

  private connectSnowflake = async (): Promise<any> =>
    new Promise((resolve: any, reject: any) => {
      try {
        snowflake.configure(this.snowflakeConfig);
        const connection: snowflake.Connection = snowflake.createConnection(
          this.snowflakeEnvironment,
        );

        if (connection) {
          connection.connect(
            (err: snowflake.SnowflakeError, conn: snowflake.Connection) => {
              if (err) {
                reject(err);
              } else {
                this.logger.log(`Connected Snowflake Id: ${conn.getId()}`);
                resolve(conn);
              }
            },
          );
        }
      } catch (err) {
        reject(err);
      }
    });

  private disconnectSnowflake = async (connection: snowflake.Connection) =>
    new Promise((resolve: any, reject: any) => {
      try {
        connection.destroy(
          (err: snowflake.SnowflakeError, _conn: snowflake.Connection) => {
            if (err) {
              this.logger.error(
                'Unable to disconnect Snowflake: ' + err.message,
              );
              reject(err);
            } else {
              this.logger.log(
                `Disconnected Snowflake Id: ${connection.getId()}`,
              );
              resolve();
            }
          },
        );
      } catch (err) {
        reject(err);
      }
    });

  private cancelStatementSnowflake = async (statement: snowflake.Statement) =>
    new Promise((resolve: any, reject: any) => {
      try {
        statement.cancel(
          (err: snowflake.SnowflakeError, _stmt: snowflake.Statement) => {
            if (err) {
              this.logger.error('Error while cancel statement ' + err.message);
              reject(err);
            } else {
              this.logger.log('Successfully aborted statement');
              resolve();
            }
          },
        );
      } catch (err) {
        reject(err);
      }
    });

  public executeQuery = async (
    req: SnowflakeQueryInterface,
  ): Promise<SnowflakeResultInterface> =>
    new Promise(async (resolve: any, reject: any) => {
      try {
        const connection: snowflake.Connection = await this.connectSnowflake();

        /* PAGINATION */
        const startIndex: number = req.startIndex ? req.startIndex : 0;
        const endIndex: number = req.count
          ? startIndex + Math.min(req.count, 999) - 1
          : startIndex + 999;

        connection.execute({
          sqlText: req.query,
          binds: req.binds ? req.binds : [],
          streamResult: true,
          complete: (
            completeErr: snowflake.SnowflakeError,
            statement: snowflake.Statement,
            _rows: any,
          ) => {
            if (completeErr) {
              this.logger.error(completeErr);
              reject(completeErr);
            }

            const rowsArr: any[] = [];

            this.logger.log(`Query id: ${statement.getStatementId()}`);

            const stream = statement.streamRows({
              start: startIndex,
              end: endIndex,
            });

            stream.on('error', async (streamErr: Error) => {
              this.logger.error('Unable to consume all rows');

              await this.cancelStatementSnowflake(statement);
              await this.disconnectSnowflake(connection);

              reject(streamErr);
            });

            stream.on('data', (row: any) => {
              rowsArr.push(row);
            });

            stream.on('end', async () => {
              this.logger.log('All rows consumed');
              resolve({
                total: statement.getNumRows(),
                pageSize: rowsArr.length,
                hasNextPage: endIndex < statement.getNumRows() - 1,
                results: rowsArr,
              });

              await this.disconnectSnowflake(connection);
            });
          },
        });
      } catch (err) {
        reject(err);
      }
    });
}

I hope this article has been helpful to you. If you have any questions or suggestions, please feel free to contact me. Thank you for reading!👋

Configuring HTTP Basic Auth on an AWS Elastic Beanstalk application

Benjamin Bourgeois — Thu, 07 Apr 2022 17:53:05 +0000

Elastic Beanstalk is a platform within Amazon Web Service that is used for deploying and scaling web applications. It lets developers uploading their application to the AWS cloud, via AWS CodePipeline to named one, and then you can forget about the deployment.

And it seems like AWS has changed some stuff in newer versions of Elastic Beanstalk that uses Amazon Linux 2. And so most of the configuration you can find on internet are no longer working.

The following steps describe the newer approach to deploy an app with HTTP Basic Auth.

1. Create the .htpasswd

.htpasswd is used to store usernames and password for basic authentication of HTTP users. Elastic Beanstalk defines a large number of configuration options that you can use to configure your environment's behavior and the resources that it contains. We will use one of theses :)

Create, at the root of your application bundle, a folder named .ebextensions and add a file named 00-http_basic_auth.config with the following code.

files:
  /etc/nginx/.htpasswd:
    mode: "000755"
    owner: root
    group: root
    content: |
      user:password

🚨 Replace user and password with your combination. You can easily find on internet how to generate a password for this file :)

2. Overriding the default location

Next, we need to overwrite the default nginx location conf provided by Beanstalk.

To do so, create a file in the bundle of your application at the location .platform/nginx/conf.d/elasticbeanstalk/00_application.conf.

Then, add this code. This is the default nginx location conf to which I added the last two lines.

ℹ️ Don't forget to change the port number depends on your application

location / {
    proxy_pass          http://127.0.0.1:8080;
    proxy_http_version  1.1;

    proxy_set_header    Connection          $connection_upgrade;
    proxy_set_header    Upgrade             $http_upgrade;
    proxy_set_header    Host                $host;
    proxy_set_header    X-Real-IP           $remote_addr;
    proxy_set_header    X-Forwarded-For     $proxy_add_x_forwarded_for;

    auth_basic "Restricted";
    auth_basic_user_file /etc/nginx/.htpasswd;
}

3. Make HTTP basic auth works with health check

The configuration is ready so far and if you try to deploy your app, the HTTP Basic Auth will work but Beanstalk will indicate that your app is unhealthy because the health check now need to authenticate itself. To avoid this, we can make one path publicly available.

Add to your previously created file .platform/nginx/conf.d/elasticbeanstalk/00_application.conf the following code.

location /elb-status {
    proxy_pass          http://127.0.0.1:8080/status;
}

ℹ️ Make also this path works on your app but without any sensitive information, just a health check.

Finally, we just need to change the default health check path of the Beanstalk instance.
Go on your Beanstalk instance in your AWS Console and then click on "Configuration" and "Edit" in the Load Balancer section.
Modify the default process with this health check path : /elb-status.

Save and apply changes

I hope it helped you and enjoy your HTTP Basic Auth :))

Forem: Benjamin Bourgeois

🤖 Comment structurer la mémoire de vos agents avec Google ADK

🏗️ Architecture du contexte dans ADK

🚦 Session, State et Memory

🧠 Mémoire court-terme vs long-terme

🔄 SessionService : Garantir la continuité

📝 State : Le bloc-notes dynamique de l'agent

💡 Gestion de la portée via les préfixes

🧠 MemoryService : Choisir son moteur de connaissances

🚀 Le workflow complet

🤖 Vers une IA qui apprend vraiment

Web3 : Le bilan de Google Cloud sur la blockchain en 2025

🤖 Des agents IA connectés à la blockchain

🏦 Stablecoins et “Universal Ledger” : Google veut sa propre infrastructure de paiement

🌐 Un écosystème Web3 en expansion

Ce qu’il faut retenir

Conclusion

🤖 Déployer son agent sur Google Vertex AI Agent Engine

❓Comprendre Vertex AI Agent Engine et ses avantages

💡 Les principaux avantages de Vertex AI Agent Engine

🚀 Déployer son agent avec le framework ADK (Agent Development Kit)

1. Installation et initialisation du projet

2. Création d’un agent

3. Déploiement

🚀 Déployer un agent avec un autre framework grâce au SDK Vertex AI

1. Installation et initialisation du projet

2. Création d’un agent

3. Intégration de l’agent dans Vertex AI

4. Déploiement

💬 Interagir avec l’agent déployé

💡 En résumé

💡 Update 10/11/2025 – Vertex AI Agent Engine Express Mode

Pour approfondir le sujet :

DuckDB on AWS Lambda: The Easy Way with Layers

🦆 What is DuckDB

🤯 The Challenge with DuckDB on Lambda

✅ Solution

👉🏼 Back to the Initial Problem

Conclusion

Google Agent Development Kit : Core Concept

🔍 What is Google Agent Development Kit?

🧩 Core Concept and Architecture of ADK

🚀 Let’s implement our first multi-agent system

1️⃣ Step 1: Defining our specialized agents

👤 The places_finder Agent

👤 The geocode_finder Agent

👤 The path_planner Agent

👤 The root_agent

2️⃣ Step 2: Running the agent

What's Next?

🤖 Using Gemini Code Assist for Code Reviews in My Personal Project

🚀 What Gemini Actually Does on my PR

📄 1. Pull Request Summary

🕵🏼‍♂️ 2. Code Review Summary

🔍 3. Code Reviews comments and proposals

🙋🏼 4. Answer questions

🛠️ Customizing Gemini for Your Project

Guiding Gemini on how to review your code.

🔧 config.yaml — Control what Gemini does

📘 styleguide.md — Teach it your rules

🧵 Final Thoughts

📝 Official docs

Web3 : Le bilan de Google Cloud sur la blockchain en 2024

Un nouveau portail Web3, enrichi et consolidé

SUI : Une collaboration centrée sur l’IA

Une infrastructure RPC renforcée

Blockchain et gaming : GameStack et l’essor du Web3 dans les jeux

Un message fort contre la fraude

La suite en 2025

Reflecting on my Hacktoberfest 2024 journey

Getting Started with Hacktoberfest 🎉

The Projects I Contributed To 🏗️

Git Town

Open Food Facts

Challenges and Learning Moments 🤗

Looking Forward 🙌

Démarrez votre projet Web3 : panorama tech du développement de smart contracts en 2024

Choisir la bonne plateforme : une décision stratégique pour la viabilité de votre projet.

Ethereum

Ethereum + Layer 2

👤 The `places_finder` Agent

👤 The `geocode_finder` Agent

👤 The `path_planner` Agent

👤 The `root_agent`

🔧 `config.yaml` — Control what Gemini does

📘 `styleguide.md` — Teach it your rules