Building Personalized Agents with Google ADK, MCP, Gemini, and Memory Bank

AI agents are becoming more than just chatbots.
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:
| Component | Purpose |
|---|---|
| MCP | Connects the agent to external tools and systems |
| ADK | Orchestrates the agent’s reasoning and workflow |
| Memory Bank | Stores long-term personalized user context |
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:
| Technology | Role |
|---|---|
| Google ADK | Agent orchestration |
| MCP / FastMCP | Tool integration |
| Gemini 2.5 Flash | Profile analysis and reasoning |
| Python | Backend logic |
| FastAPI | Backend API |
| React | Frontend UI |
| TailwindCSS | Styling |
| Docker | Containerization |
| Google Cloud Run | Deployment |
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.
About the author
AI ML Enthusiast Passionate About Learning & Leading
Comments
Join the discussionNo comments yet. Be the first to comment.

