A chatbot usually responds to a user’s question. But a real AI agent can connect with tools, analyze data, remember context, and perform useful tasks across multiple steps.

Recently, I attended/followed a workshop titled “Building Personalized Agents with ADK, MCP, and Memory Bank”, where I explored how modern agents can be built using Google’s agent ecosystem.

As part of this learning, I also worked on and deployed a project called:

GitHub Dev Card Generator

GitHub Repository: https://github.com/MRSHAKILS/Agents-with-ADK-CP-And-Memory-Bank

The idea was simple but powerful:

Can an AI agent analyze a GitHub profile and generate a personalized developer card based on that person’s coding activity?

The answer is yes.

Using Google ADK, MCP, Gemini 2.5 Flash, FastAPI, React, and Google Cloud Run, I built an agentic application that can analyze a developer’s GitHub profile and generate a visually styled, shareable card.

What This Project Does

The project is a GitHub Dev Card Generator.

A user enters a GitHub username, and the system analyzes the public GitHub profile to generate a personalized developer card.

The generated card includes things like:

• top skills

• developer vibe

• fun facts

• visual theme

• GitHub-based profile insights

• shareable HTML card

The agent does not just display raw GitHub data. It uses Gemini to understand the developer’s profile and infer a meaningful identity from it.

For example, based on the user’s repositories and activity, the system can assign themes like:

• hacker

• builder

• researcher

• designer

• open-source hero

This makes the output more personalized and interesting than a normal GitHub profile summary.

Why Personalized Agents Matter

Most AI applications today feel temporary.

You open a chat, ask something, get a response, and then everything is forgotten when the session ends.

But real-world applications need memory.

A useful AI assistant should remember:

• user preferences

• previous choices

• design style

• coding interests

• repeated workflows

• context from past interactions

That is where the concept of personalized agents becomes important.

In the workshop, the architecture focused on three important parts:

This combination creates agents that are not only intelligent but also more useful over time.

What Is ADK?

ADK stands for Agent Development Kit.

In simple words, ADK helps developers build AI agents in a structured way.

Instead of writing one huge prompt and hoping the model does everything correctly, ADK helps organize:

• agent logic

• tool usage

• reasoning flow

• state management

• multi-step execution

In this project, ADK is used to orchestrate the agentic workflow.

The agent takes the user input, decides which tools are needed, analyzes the GitHub data, and generates the final developer card.

What Is MCP?

MCP stands for Model Context Protocol.

MCP acts like a bridge between the AI model and external tools.

A model by itself cannot directly scrape GitHub, call APIs, save files, or generate structured outputs unless we connect it with tools.

MCP provides a standard way to expose those tools to the agent.

In this project, MCP/FastMCP is used to define tools such as:

• scraping GitHub profile data

• analyzing profile information

• generating the HTML card

• saving the final output

This makes the project more modular and agent-friendly.

What Is Memory Bank?

Memory Bank is used for long-term memory.

Short-term memory is what the agent remembers during the current conversation.

Long-term memory is what the agent can remember across sessions.

For example:

I prefer dark cyberpunk-style designs.

A memory-enabled agent can store that preference and use it later without asking again.

In the workshop, Memory Bank was used to demonstrate how agents can remember user preferences and personalize future outputs.

This is a very important concept because it moves AI applications from simple one-time tools toward truly personalized assistants.

Project Tech Stack

Here is the main tech stack used in my project:

The project is also Dockerized and deployed to Google Cloud Run, making it closer to a real-world production-style application.

Project Structure

The project is organized into backend and frontend parts.

.
├── backend/
│   ├── agent.py
│   ├── main.py
│   ├── mcp_server.py
│   ├── requirements.txt
│   └── Dockerfile
├── frontend/
│   ├── index.html
│   └── Dockerfile
├── docker-compose.yml
├── .env.example
├── GEMINI.md
└── README.md

Important files

agent.py

This file contains the Google ADK agent definition and orchestration logic.

main.py

This is the FastAPI application entry point.

mcp_server.py

This file contains the MCP/FastMCP tools used by the agent.

frontend/index.html

This is the React frontend where the user enters a GitHub username and views the generated card.

docker-compose.yml

This helps run the frontend and backend together locally.

How the Workflow Works

The workflow is simple but powerful.

1. User enters GitHub username

The user provides a GitHub username from the frontend.

2. MCP tool collects GitHub data

The MCP server uses a scraping/API tool to collect public GitHub profile and repository information.

3. Gemini analyzes the profile

Gemini 2.5 Flash analyzes the developer’s repositories and activity.

It identifies things like:

• top skills

• coding style

• project interests

• developer personality

• possible theme

4. The agent generates a card

The system generates a beautiful HTML card using TailwindCSS.

5. The card is saved and displayed

The final card can be viewed, shared, or downloaded.

This makes the project feel like a personalized AI-powered developer branding tool.

Example Use Case

Suppose a developer enters their GitHub username.

The agent may analyze their repositories and generate something like:

Developer Vibe: Full-Stack Builder
Top Skills: Python, JavaScript, React, FastAPI
Theme: Builder
Fun Fact: Frequently builds practical tools and web-based systems

Then it creates a styled developer card based on that analysis.

This can be useful for:

• portfolios

• personal branding

• hackathon profiles

• LinkedIn posts

• GitHub README sections

• developer introductions

Running the Project Locally

First, clone the repository:

git clone https://github.com/MRSHAKILS/Agents-with-ADK-CP-And-Memory-Bank.git

Go inside the project folder:

cd Agents-with-ADK-CP-And-Memory-Bank

Copy the environment file:

cp .env.example .env

Then add your Gemini API key:

GOOGLE_API_KEY=your_gemini_api_key_here

Run the project using Docker Compose:

docker-compose up --build

After running, the frontend and backend should be available locally.

Frontend:

http://localhost:8080

Backend:

http://localhost:8000

Deployment

The project is also designed for deployment using Google Cloud Run.

This is important because building something locally is only the first step.

Deploying it to the cloud makes it accessible, scalable, and closer to a real-world application.

Cloud deployment also helped me understand:

• Docker-based deployment

• backend/frontend separation

• environment variables

• cloud-hosted AI applications

• practical production workflow

What I Learned

This workshop and project helped me understand several important concepts.

1. AI agents are not just chatbots

A chatbot responds. An agent reasons, uses tools, and performs tasks.

2. MCP makes tool integration cleaner

Instead of tightly coupling everything into one backend, MCP allows tools to be exposed in a structured way.

3. ADK helps organize agent workflows

ADK makes the agent easier to manage, especially when there are multiple steps and tools involved.

4. Gemini can analyze developer identity

Gemini was useful for converting raw GitHub profile data into meaningful insights.

5. Memory is the future of personalization

Memory Bank shows how agents can become more helpful over time by remembering user preferences.

Why This Project Is Useful

This project may look like a GitHub card generator, but the core idea is much bigger.

The same architecture can be used to build:

• personalized portfolio assistants

• resume improvement agents

• coding profile analyzers

• recruiter tools

• learning assistants

• project recommendation systems

• developer branding tools

• AI agents that remember user preferences

The important lesson is not only the final card.

The important lesson is the architecture:

User Input → MCP Tools → ADK Agent → Gemini Reasoning → Personalized Output

With Memory Bank added, it becomes even more powerful:

User Input → Memory Retrieval → MCP Tools → ADK Agent → Gemini Reasoning → Personalized Output

That is the foundation of many next-generation AI applications.

Final Thoughts

This workshop gave me a clearer understanding of how modern personalized agents are built.

The combination of ADK, MCP, Gemini, and Memory Bank creates a strong foundation for building practical AI applications.

For my project, I used these ideas to build a GitHub Dev Card Generator that analyzes a developer profile and creates a personalized visual card.

The biggest takeaway for me was:

The future of AI applications is not just about generating answers. It is about building agents that can use tools, remember context, personalize experiences, and solve real problems.

This project was a great learning experience, and I am excited to keep exploring more agentic AI systems.