DEV Community: Ömer Berat Sezer

Langchain Agent with Structured Tools Schema & Langfuse using AWS Bedrock Nova 🤖

Ömer Berat Sezer — Tue, 24 Mar 2026 09:53:12 +0000

AI agents are becoming the brains of modern apps, they make decisions, use tools, and give smart responses in real time. But to build them properly at scale, you need a solid agent framework (e.g. LangChain/LangGraph, AWS Strands Agents, etc.).

In this post we’ll look at how LangChain agents use structured tool calling to do that. Also, we'll configure Langfuse to follow toolcalls, flow, input/output.

What is Tool Calling?

Tool calling is when an AI agent invokes external functions or APIs to perform actions or retrieve data.
The agent decides to call a tool based on the user’s request and the available tool descriptions.
It generates a structured request (following a schema) with the required parameters for that tool.

Why Structured Tool Calling Important?

Tool calling with a structured schema ensures that inputs and outputs are predictable, validated, and machine-readable, reducing ambiguity, hallucination and runtime errors.
It also enables reliable automation and easier integration by enforcing consistent structured data.

Whether you’re curious about how agents actually work or looking to build one yourself, this is your starting point 😉.

Dependencies & Configuration
Langchain Agent with AWS Bedrock, Nova Pro
Tools
Structured Output Schema
Langfuse Handler
All Code & Demo
Conclusion
References

Dependencies & Configuration

Please install dependencies and libraries:

python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt
# deactivate

Requirements.txt:

langchain>=1.0.0
langchain-aws>=1.2.0
langgraph>=1.0.0
python-dotenv>=1.0.0
boto3>=1.34.0
langfuse>=4.0.0

Enable AWS Bedrock model access in your region (e.g. eu-central-1, us-east-1)
- AWS Bedrock > Bedrock Configuration > Model Access > AWS Nova-Pro, or Claude 3.7 Sonnet
In this code, we'll use AWS Nova-Pro, because it's served in different regions by AWS.
After model access, give permission in your IAM to access AWS Bedrock services: AmazonBedrockFullAccess
2 Options to reach AWS Bedrock Model using your AWS account:
- AWS Config: With aws configure, to create configand credentials files
- Getting variables using .env file: Add .env file:

AWS_ACCESS_KEY_ID= PASTE_YOUR_ACCESS_KEY_ID_HERE
AWS_SECRET_ACCESS_KEY=PASTE_YOUR_SECRET_ACCESS_KEY_HERE

Agent with AWS Bedrock, Nova Pro

Langchain agent with Bedrock:

from langchain_aws import ChatBedrockConverse
from langchain.agents import create_agent
from langchain.agents.structured_output import ToolStrategy

llm = ChatBedrockConverse(
    model="us.amazon.nova-pro-v1:0",
    temperature=0,
    # Reads AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_DEFAULT_REGION from .env
)

tools = [search_books, search_movies, get_trending]

agent = create_agent(
    model=llm,
    tools=tools,
    response_format=ToolStrategy(RecommendationResult),
    system_prompt=(
        "You are a creative media concierge. "
        "Detect the user's mood, search for matching books and movies using your tools, "
        "then return a fully structured recommendation."
    ),
)

Tools

Tools definitions as function:

from langchain_core.tools import tool

@tool
def search_books(mood: str) -> list[dict]:
    """Search the book catalogue by mood keyword."""
    mood = mood.lower()
    return [b for b in BOOK_DB if any(mood in m for m in b["moods"])]

@tool
def search_movies(mood: str) -> list[dict]:
    """Search the movie catalogue by mood keyword."""
    mood = mood.lower()
    return [m for m in MOVIE_DB if any(mood in t for t in m["moods"])]


@tool
def get_trending(media_type: Literal["book", "movie"]) -> list[dict]:
    """Return the 3 most recently released items for the given media type."""
    db = BOOK_DB if media_type == "book" else MOVIE_DB
    return sorted(db, key=lambda x: x["year"], reverse=True)[:3]

Structured Output Schema

Tool calling with a structured schema ensures that inputs and outputs are predictable, validated, and machine-readable, reducing ambiguity and runtime errors. It also enables reliable automation and easier integration with downstream systems by enforcing consistent data contracts.

We can design structured tool output with Pydantic basemodel and fields.

from pydantic import BaseModel, Field

# Structured output schema
class MediaItem(BaseModel):
    """A single book or movie recommendation."""
    title: str           = Field(description="Title of the book or movie")
    creator: str         = Field(description="Author (book) or director (movie)")
    year: int            = Field(description="Year of release or publication")
    media_type: Literal["book", "movie"] = Field(description="Type of media")
    reason: str          = Field(description="Why this matches the user's mood, 1-2 sentences")
    mood_tags: list[str] = Field(description="Mood tags, lowercase, 1-3 words each")


class RecommendationResult(BaseModel):
    """Structured recommendation response returned by the agent."""
    detected_mood: str               = Field(description="The mood detected from the user's message")
    confidence: float                = Field(description="Confidence score 0.0-1.0", ge=0.0, le=1.0)
    recommendations: list[MediaItem] = Field(description="List of 2-4 recommendations")
    summary: str                     = Field(description="One-sentence summary of the recommendations")

Langfuse Handler

Langfuse helps by providing detailed tracing, logging, and evaluation of LLM interactions, making it easier to debug and improve agent behavior.
It also enables monitoring of performance, costs, and user flows, which is critical for optimizing and maintaining reliable AI applications in production.

from langfuse import Langfuse
from langfuse.langchain import CallbackHandler

langfuse = Langfuse(
    public_key = os.getenv("LANGFUSE_PUBLIC_KEY"),
    secret_key = os.getenv("LANGFUSE_SECRET_KEY"),
    host       = os.getenv("LANGFUSE_BASE_URL"),
)
langfuse_handler = CallbackHandler()

result = agent.invoke({
            "messages": [{"role": "user", "content": user_message}]
        },
        {
            "callbacks": [langfuse_handler]   # if you don't want to use langfuse, remove callbacks and handler
        }
    )

All Code & Demo

GitHub Link: Project on GitHub

Agent App:

import os
from pydantic import BaseModel, Field
from typing import Literal
from langchain_aws import ChatBedrockConverse
from langchain_core.tools import tool
from langchain.agents import create_agent
from langchain.agents.structured_output import ToolStrategy
from langfuse import Langfuse
from langfuse.langchain import CallbackHandler
from dotenv import load_dotenv
load_dotenv()

langfuse = Langfuse(
    public_key = os.getenv("LANGFUSE_PUBLIC_KEY"),
    secret_key = os.getenv("LANGFUSE_SECRET_KEY"),
    host       = os.getenv("LANGFUSE_BASE_URL"),
)
langfuse_handler = CallbackHandler()

# Structured output schema
class MediaItem(BaseModel):
    """A single book or movie recommendation."""
    title: str           = Field(description="Title of the book or movie")
    creator: str         = Field(description="Author (book) or director (movie)")
    year: int            = Field(description="Year of release or publication")
    media_type: Literal["book", "movie"] = Field(description="Type of media")
    reason: str          = Field(description="Why this matches the user's mood, 1-2 sentences")
    mood_tags: list[str] = Field(description="Mood tags, lowercase, 1-3 words each")


class RecommendationResult(BaseModel):
    """Structured recommendation response returned by the agent."""
    detected_mood: str               = Field(description="The mood detected from the user's message")
    confidence: float                = Field(description="Confidence score 0.0-1.0", ge=0.0, le=1.0)
    recommendations: list[MediaItem] = Field(description="List of 2-4 recommendations")
    summary: str                     = Field(description="One-sentence summary of the recommendations")


# Mock catalogue tools
BOOK_DB = [
    {"title": "The Midnight Library",   "creator": "Matt Haig",       "year": 2020, "moods": ["melancholic", "hopeful", "reflective"]},
    {"title": "Project Hail Mary",      "creator": "Andy Weir",       "year": 2021, "moods": ["adventurous", "curious", "uplifting"]},
    {"title": "Anxious People",         "creator": "Fredrik Backman", "year": 2019, "moods": ["funny", "warm", "melancholic"]},
    {"title": "The Hitchhiker's Guide", "creator": "Douglas Adams",   "year": 1979, "moods": ["funny", "adventurous", "curious"]},
    {"title": "Atomic Habits",          "creator": "James Clear",     "year": 2018, "moods": ["motivated", "focused", "uplifting"]},
]

MOVIE_DB = [
    {"title": "Everything Everywhere All at Once", "creator": "Daniels",           "year": 2022, "moods": ["adventurous", "funny", "melancholic", "reflective"]},
    {"title": "Soul",                              "creator": "Pete Docter",        "year": 2020, "moods": ["reflective", "hopeful", "warm"]},
    {"title": "The Grand Budapest Hotel",          "creator": "Wes Anderson",       "year": 2014, "moods": ["funny", "adventurous", "warm"]},
    {"title": "Interstellar",                      "creator": "Christopher Nolan",  "year": 2014, "moods": ["curious", "adventurous", "melancholic"]},
    {"title": "Amelie",                            "creator": "Jean-Pierre Jeunet", "year": 2001, "moods": ["warm", "hopeful", "funny"]},
]


@tool
def search_books(mood: str) -> list[dict]:
    """Search the book catalogue by mood keyword."""
    mood = mood.lower()
    return [b for b in BOOK_DB if any(mood in m for m in b["moods"])]


@tool
def search_movies(mood: str) -> list[dict]:
    """Search the movie catalogue by mood keyword."""
    mood = mood.lower()
    return [m for m in MOVIE_DB if any(mood in t for t in m["moods"])]


@tool
def get_trending(media_type: Literal["book", "movie"]) -> list[dict]:
    """Return the 3 most recently released items for the given media type."""
    db = BOOK_DB if media_type == "book" else MOVIE_DB
    return sorted(db, key=lambda x: x["year"], reverse=True)[:3]

llm = ChatBedrockConverse(
    model="us.amazon.nova-pro-v1:0",
    temperature=0,
    # Reads AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_DEFAULT_REGION from .env
)

tools = [search_books, search_movies, get_trending]

agent = create_agent(
    model=llm,
    tools=tools,
    response_format=ToolStrategy(RecommendationResult),
    system_prompt=(
        "You are a creative media concierge. "
        "Detect the user's mood, search for matching books and movies using your tools, "
        "then return a fully structured recommendation."
    ),
)

def recommend(user_message: str) -> RecommendationResult:
    result = agent.invoke({
            "messages": [{"role": "user", "content": user_message}]
        },
        {
            "callbacks": [langfuse_handler]   # if you don't want to use langfuse, remove callbacks and handler
        }
    )
    return result["structured_response"]

if __name__ == "__main__":
    queries = [
        "I'm feeling a bit low today and want something that lifts my spirits.",
        "I'm in a curious and adventurous mood — blow my mind!",
        "I want something funny and light after a long week.",
    ]

    for query in queries:
        print(f"\n{'='*65}")
        print(f"USER    : {query}")
        rec: RecommendationResult = recommend(query)
        print(f"MOOD    : {rec.detected_mood}  (confidence: {rec.confidence:.0%})")
        print(f"SUMMARY : {rec.summary}")
        for item in rec.recommendations:
            icon = "book" if item.media_type == "book" else "film"
            print(f"\n  [{icon}]  {item.title} ({item.year}) — {item.creator}")
            print(f"          {item.reason}")
            print(f"          tags: {', '.join(item.mood_tags)}")

Run app.py:

python agent.py

Demo

Demo Output on GitHub (better resolution)

Langfuse on GitHub (better resolution)

Conclusion

In this post, we mentioned:

how to create agent with structured tool schema,
how to follow/debug with langfuse.

If you found the tutorial interesting, I’d love to hear your thoughts in the blog post comments. Feel free to share your reactions or leave a comment. I truly value your input and engagement 😉

For other posts 👉 https://dev.to/omerberatsezer 🧐

Would really appreciate your feedback in the comments. The post is also available on AWS Builder Center ☺️

https://builder.aws.com/content/38R7mofRmOMliZ3c8OKxutLoV4v/langchain-agent-using-structured-tool-schemas-and-aws-bedrock-nova-pro-model

References

Your comments 🤔

Which framework/s are you using to develop AI Agents (e.g. AWS Strands, Langchain/LangGraph, etc.)? Please mention in the comment your experience, your interest?
What are you thinking about Tools with Structured Schema?

AWS Strands Agents 🧬 Sequential Multi Agent Workflow

Ömer Berat Sezer — Sun, 30 Nov 2025 10:42:03 +0000

AI agents are quickly becoming the intelligence layer of modern applications, managing decisions, triggering tools, and producing real-time responses. But scaling them effectively demands a strong underlying framework.

There are strong agent development frameworks have been released:

AWS Strands Agents
Google Agent Development Kit (ADK)
CrewAI

In addition, there are different types of agent patterns:

Sequential
Parallel
Swarm
With Feedback Loop
Aggregator
Autonomous

In this post, we’ll implement an end-to-end sequential agent app using AWS Strands, AWS Bedrock and AWS Nova, FastAPI, and a Streamlit UI.

What is AWS Strands Agents?
Sequential Multi Agent Workflow App
- Installing Libraries & Reaching LLM Model
- Application Code
- Sample Prompt / Output
Conclusion
References

What is AWS Strands Agents?

Strands agent is an open-source framework to develop AI agents to run anywhere:
- VSCode, Terminal,
- Docker Container,
- AWS Bedrock AgentCore,
- AWS Lambda,
- AWS ECS (Elastic Container Service),
- AWS EKS (Elastic Kubernetes Service),
Really good documentation to view/learn agents, tools, workflows, model providers, streaming, multi-agent etc.
- https://strandsagents.com/

Sequential Multi Agent Workflow App

Installing Libraries & Reaching LLM Model

Please install AWS Strands Agents & Tools libraries:

pip install strands-agents
pip install strands-agents-tools strands-agents-builder

Enable AWS Bedrock model access in your region or US-West-2
- AWS Bedrock > Bedrock Configuration > Model Access > AWS Nova-Pro, or Claude Opus 4.5
In this code, we'll use AWS Nova-Pro, because it's served in different regions by AWS.
After model access, give permission in your IAM to access AWS Bedrock services: AmazonBedrockFullAccess
2 Options to reach AWS Bedrock Model using your AWS account:
- AWS Config: With aws configure, to create configand credentials files
- Getting variables using .env file: Add .env file:

AWS_ACCESS_KEY_ID= PASTE_YOUR_ACCESS_KEY_ID_HERE
AWS_SECRET_ACCESS_KEY=PASTE_YOUR_SECRET_ACCESS_KEY_HERE

Application Code

We'll create 3 agents sequential workflow:
- Destination Researcher -> Travel Guide Generator -> Client Communicator
Out of one the agent will be used as input of another agent.
Tools can be attached to different agents.

GitHub Link: Project on GitHub

Agent App:

# agent.py
from fastapi import FastAPI, Request, HTTPException
from pydantic import BaseModel
from strands import Agent, tool
from strands.models import BedrockModel
from strands_tools import calculator, current_time, python_repl

MODEL = "us.amazon.nova-pro-v1:0"

bedrock_model = BedrockModel(
    model_id=MODEL,
    temperature=0.7, 
    top_p=0.9,
)

researcher_agent = Agent(
    model=bedrock_model,
    system_prompt=(
        "You are a Destination Researcher. Your primary goal is to gather detailed, high-level information for the city or "
        "location mentioned by the user. Do NOT create a day-to-day itinerary. "
        "Focus on these categories: "
        "1. **Most Attractive Places/Landmarks** (Top 5 must-sees). "
        "2. **Key Historical Facts** (3-4 fascinating historical points). "
        "3. **Best Areas to Stay** (3 distinct neighborhood suggestions with descriptions). "
        "4. **Best Local Foods** and 3 specific restaurant/street food suggestions. "
        "5. **3-5 Suggested Web Pages** for further reading (e.g., official tourism, reputable travel blogs)."
        "Report all this raw information clearly and in separate, labeled sections."
    ),
    tools=[calculator, current_time]
)

travel_guide_agent = Agent( 
    model=bedrock_model,
    system_prompt=(
        "You are a Senior Travel Guide Generator. You will receive raw destination data from a Researcher. "
        "Your goal is to synthesize this data into a structured, engaging, and comprehensive travel guide."
        "Organize the information exactly into the following sections: 'Must-See Attractions', 'Historical Highlights', 'Where to Stay', and 'Culinary Delights'. "
        "Do NOT create a 5-day itinerary. Simply structure the gathered facts into a beautiful guide format. "
        "Use Python/Calculator only if complex data aggregation is needed (unlikely for this task, but keep available)."
    ),
    tools=[python_repl, calculator]
)

writer_agent = Agent(
    model=bedrock_model,
    system_prompt=(
        "You are the Client Relations Manager. You will receive a structured travel guide. "
        "Your goal is to write a professional and clear final response to the client. "
        "Include the full structured guide and prominently feature the 'Suggested Web Pages' section at the end. "
        "Frame the guide as a 'Get Started' resource for their trip research. "
        "Keep the tone encouraging and client-focused."
    ),
    tools=[]
)

app = FastAPI()

class QueryRequest(BaseModel):
    query: str

@app.post("/ask")
async def ask(request: QueryRequest):
    """
    Executes a sequential travel guide workflow: Destination Researcher -> Travel Guide Generator -> Client Communicator
    """
    query = request.query
    try:
        # Step 1: Researcher (Gathers raw facts)
        research_output = researcher_agent(query, stream=False)

        # Step 2: Travel Guide Generator (Structures the facts)
        planner_prompt = (
            f"Generate a comprehensive travel guide based on the user's request: '{query}' "
            f"and the following raw information (DO NOT create an itinerary): {research_output}"
        )
        guide_output = travel_guide_agent(planner_prompt, stream=False)

        # Step 3: Writer (Formats the final response)
        writer_prompt = (
            f"User Inquiry: {query}\n\n"
            f"Synthesized Travel Guide Content: {guide_output}\n\n"
            "Please write the final client response (complete guide, not like email):"
        )
        final_response = writer_agent(writer_prompt, stream=False)

        return {
            "workflow_steps": {
                "raw_research_data": str(research_output),
                "structured_guide_content": str(guide_output)
            },
            "response": str(final_response)
        }

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Workflow processing failed: {e}")

if __name__ == "__main__":
    import uvicorn
    uvicorn.run("agent:app", host="0.0.0.0", port=8000)

Run app.py:

uvicorn agent:app --host 0.0.0.0 --port 8000

Streamlit UI:

# app.py
import streamlit as st
import requests
import json 

st.set_page_config(page_title="AWS Strands Workflow", layout="centered")

st.title("AWS Strands Agent")

# initialize chat history
if "messages" not in st.session_state:
    st.session_state.messages = []

user_query = st.chat_input("Ask for system file tool commands or anything...")

if user_query:
    st.session_state.messages.append({"role": "user", "content": user_query})

    try:
        response = requests.post("http://localhost:8000/ask", json={"query": user_query})
        response.raise_for_status()

        response_json = response.json()
        assistant_text = response_json["response"]

    except Exception as e:
        assistant_text = f"Error: {str(e)}"

    st.session_state.messages.append({"role": "assistant", "content": assistant_text})

# display all messages in order
for msg in st.session_state.messages: 
    st.chat_message(msg["role"]).markdown(msg["content"])

Run app.py:

streamlit run app.py
or
python3 -m streamlit run app.py

Sample Prompt / Output

Prompt: I want to go to Maldives, give me information about Maldives?

Welcome to your comprehensive travel guide for the Maldives! We're excited to help you begin your journey to this stunning paradise. Below, you'll find everything you need to know about the must-see attractions, historical highlights, where to stay, and culinary delights that await you in the Maldives. 

### Must-See Attractions
1. **Male' National Mosque** - The largest mosque in the Maldives, renowned for its breathtaking architecture and tranquil ambiance.
2. **HP Reef** - A world-class dive site celebrated for its rich marine biodiversity and vibrant coral reefs.
3. **Kurumba Beach** - A stunning beach with pristine white sands and crystal-clear waters, perfect for relaxation and various water sports.
4. **Sultan Park** - A serene park in Male' featuring a replica of the Islamic Centre and a peaceful pond, offering a glimpse into the local culture.
5. **Sea Turtle Excursion** - Numerous islands provide opportunities to observe sea turtles in their natural habitat, a must-do for wildlife enthusiasts.

### Historical Highlights
1. **Buddhist History** - Before embracing Islam in the 12th century, the Maldives were a Buddhist nation, reflecting a rich cultural heritage.
2. **Sultanate Era** - The Maldives were governed by a sultanate for centuries, a period that shaped the nation's history and traditions.
3. **Independence from the UK** - The Maldives achieved independence from the United Kingdom on July 26, 1965, marking a significant milestone in its history.
4. **Tsunami of 2004** - The 2004 Indian Ocean tsunami had a profound impact on the Maldives, leading to extensive reconstruction and resilience efforts.

### Where to Stay
1. **Male'** - The vibrant capital city, offering a deep dive into local culture and convenient access to major attractions.
2. **North Male' Atoll** - Renowned for its luxurious resorts and exceptional diving opportunities, ideal for a lavish getaway.
3. **Vaavu Atoll** - A serene and less crowded atoll, perfect for travelers seeking a more intimate and authentic Maldivian experience.

### Culinary Delights
1. **Garudhiya** - A traditional fish soup, often enjoyed during special occasions and celebrations.
2. **Mas Huni** - A popular breakfast dish made from tuna, coconut, and onions, reflecting the Maldivian love for seafood.
3. **Heka** - A delightful Maldivian snack made from rice flour and coconut, offering a taste of local flavors.

### Suggested Web Pages
To further enhance your trip research, we recommend visiting the following websites:
- [Visit Maldives Official Tourism Website](https://visitmaldives.com/)
- [Lonely Planet - Maldives Travel Guide](https://www.lonelyplanet.com/maldives)
- [TripAdvisor - Maldives](https://www.tripadvisor.com/Tourism-g293955-Maldives-Vacations.html)
- [National Geographic - Maldives](https://www.nationalgeographic.com/travel/destination/maldives)

We hope this guide helps you get started on planning your dream trip to the Maldives. If you have any more questions or need further assistance, please feel free to reach out. Safe travels and enjoy your adventure!

Conclusion

In this post, we mentioned:

how to access AWS Bedrock Foundation Models (Nova-Pro),
how to implement sequential multi agents workflow with Nova-Pro, Fast API, Streamlit UI.

For other posts 👉 https://dev.to/omerberatsezer 🧐

References

Your comments 🤔

Which tools are you using to develop AI Agents (e.g. AWS Strands, Google ADK, CrewAI, Langchain, etc.)? Please mention in the comment your experience, your interest?
Which agent patterns (sequential, parallel, swarm, feedback loop, aggregator, autonomous, etc.) are best suited for which use cases?

Multi-agents: Parallel Agents using Google ADK 🤖 Gemini, Fast API, Streamlit - Report Generation

Ömer Berat Sezer — Wed, 13 Aug 2025 08:50:09 +0000

In the past 4-5 months, TWO powerful AI agent development frameworks have been released:

Google Agent Development Kit (ADK)
AWS Strands Agents

You can view the other posts in the Google ADK series above. In our current post, we’ll dive into the Google Agent Development Kit (ADK) and show how to create workflow parallel agents using ADK, Gemini 2.5, FastAPI, and a Streamlit interface.

What is Google Agent Development Kit?
What is Multi-Agent, Parallel Agents?
Agent App
- Installing Dependencies & Reaching Gemini Model
- Frontend - Streamlit UI
- Backend - Agent
- Run & Demo: To create Game
Conclusion
References

What is Google Agent Development Kit?

Agent Development Kit (ADK) is an open-source framework to develop AI agents to run anywhere:
- VSCode, Terminal,
- Docker Container
- Google CloudRun
- Kubernetes

What is Multi-Agent, Parallel Agents?

The ParallelAgent is a workflow agent designed to run its sub-agents simultaneously, significantly accelerating workflows where tasks are independent.

When the run_async() method of the ParallelAgent is invoked:

Simultaneous Execution: It triggers the run_async() method for all agents in the sub_agents list at the same time.
Isolated Processes: Each sub-agent runs in its own thread of execution without automatically sharing conversation history or state with the others.
Gathering Results: After execution, the ParallelAgent handles collecting the results from each sub-agent. These results are typically accessible through a list or event-based mechanism, but their order might not be predictable.

It's important to recognize that sub-agents within a ParallelAgent operate independently. If coordination or data sharing is required between them, it must be handled manually. Here are some possible strategies:

Shared InvocationContext: You can provide all sub-agents with the same InvocationContext, using it as a shared data container. However, to prevent race conditions, concurrent access must be managed carefully—typically with synchronization mechanisms like locks.
External State Handling: Leverage external tools such as databases or message queues to manage shared state and facilitate inter-agent communication.
Post-Execution Coordination: Let each sub-agent complete its task independently, then process and reconcile their outputs afterward to coordinate data.

Details: https://google.github.io/adk-docs/agents/workflow-agents/parallel-agents/#independent-execution-and-state-management

Agent App

Sample project on GitHub:

https://github.com/omerbsezer/Fast-LLM-Agent-MCP/tree/main/agents/google_adk/07-multiagent-workflow-parallel

Installing Dependencies & Reaching Gemini Model

Go to: https://aistudio.google.com/
Get API key to reach Gemini
Please add .env with Gemini and Serper API Keys

# .env
GOOGLE_GENAI_USE_VERTEXAI=FALSE
GOOGLE_API_KEY=PASTE_YOUR_ACTUAL_API_KEY_HERE

Please install requirements:

fastapi
uvicorn
google-adk
google-generativeai

Frontend - Streamlit UI

# app.py
import streamlit as st
import requests

st.set_page_config(page_title="Agent Chat", layout="centered")

if "messages" not in st.session_state:
    st.session_state.messages = []

st.title("Multi-Agent Paralel Researcher")

for msg in st.session_state.messages:
    with st.chat_message(msg["role"]):
        st.markdown(msg["content"])

user_query = st.chat_input("Ask to search for real-time data or anything...")

# send and display user + assistant messages
if user_query:
    st.chat_message("user").markdown(user_query)
    st.session_state.messages.append({"role": "user", "content": user_query})
    try:
        response = requests.post(
            "http://localhost:8000/ask",
            json={"query": user_query}
        )
        response.raise_for_status()
        # respond is not str, it is list, because of multiple agent responds.
        all_replies = response.json().get("responses", ["No response."])

        for reply in all_replies:
            st.chat_message("assistant").markdown(reply)
            st.session_state.messages.append({"role": "assistant", "content": reply})

    except Exception as e:
        error_msg = f"Error: {str(e)}"
        st.chat_message("assistant").markdown(error_msg)
        st.session_state.messages.append({"role": "assistant", "content": error_msg})

Backend - Agent

# agent.py
from fastapi import FastAPI
from pydantic import BaseModel
from dotenv import load_dotenv
from google.genai import types
from google.adk.agents import Agent
from google.adk.agents.llm_agent import LlmAgent
from google.adk.agents.sequential_agent import SequentialAgent
from google.adk.agents.parallel_agent import ParallelAgent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.adk.memory import InMemoryMemoryService
from google.adk.tools import google_search
import uvicorn

# Load environment variables
load_dotenv()

# Define model and app constants
MODEL = "gemini-2.5-flash"
APP_NAME = "search_memory_app"
USER_ID = "user123"
SESSION_ID = "session123"

# --- Agent Definitions ---
# the Pydantic model for the output of the TopicSetterAgent
class TopicOutput(BaseModel):
    subtopic_1: str
    subtopic_2: str
    subtopic_3: str

topic_setter = LlmAgent(
    name="TopicSetterAgent",
    model=MODEL,
    instruction="""
    You are a research planner. Your task is to break the user's input query into three distinct and relevant subtopics.
    Respond ONLY in this format:

    {
    "subtopic_1": "...",
    "subtopic_2": "...",
    "subtopic_3": "..."
    }
    """,
    output_schema=TopicOutput,
    output_key="topic_output"
)

researcher_agent_1 = LlmAgent(
    name="SubResearcherOne",
    model=MODEL,
    instruction="""
    You are a research assistant. Research the subtopic: "{topic_output.subtopic_1}".
    Summarize your findings in 1-2 sentences.
    """,
    tools=[google_search],
    output_key="result_1"
)

researcher_agent_2 = LlmAgent(
    name="SubResearcherTwo",
    model=MODEL,
    instruction="""
    You are a research assistant. Research the subtopic: "{topic_output.subtopic_2}".
    Summarize your findings in 1-2 sentences.
    """,
    tools=[google_search],
    output_key="result_2"
)

researcher_agent_3 = LlmAgent(
    name="SubResearcherThree",
    model=MODEL,
    instruction="""
    You are a research assistant. Research the subtopic: "{topic_output.subtopic_3}".
    Summarize your findings in 1-2 sentences.
    """,
    tools=[google_search],
    output_key="result_3"
)

# final synthesis
merger_agent = LlmAgent(
    name="ResearchSynthesizer",
    model=MODEL,
    instruction="""
    You are a synthesis assistant. Merge the three research summaries below into a single cohesive research report.

    Subtopic 1 ({topic_output.subtopic_1}): {result_1}
    Subtopic 2 ({topic_output.subtopic_2}): {result_2}
    Subtopic 3 ({topic_output.subtopic_3}): {result_3}

    Write in this format:

    ## Research Summary on the Given Topic

    ### {topic_output.subtopic_1}
    [result_1]

    ### {topic_output.subtopic_2}
    [result_2]

    ### {topic_output.subtopic_3}
    [result_3]

    ### Conclusion
    Write 2-3 sentences summarizing the topic overall.
    """
)

parallel_research_agent = ParallelAgent(
    name="ParallelWebResearchAgent",
    sub_agents=[researcher_agent_1, researcher_agent_2, researcher_agent_3],
    description="Runs multiple research agents in parallel to gather information."
)

research_pipeline = SequentialAgent(
    name="GeneralResearchPipeline",
    description="Extracts a topic, researches it in parallel, then synthesizes a report.",
    sub_agents=[topic_setter, parallel_research_agent, merger_agent],
)

root_agent = research_pipeline

session_service = InMemorySessionService()
memory_service = InMemoryMemoryService()

app = FastAPI()

class QueryRequest(BaseModel):
    query: str

@app.on_event("startup")
async def startup_event():
    """
    Initializes the session and runner on application startup.
    """
    await session_service.create_session(
        app_name=APP_NAME,
        user_id=USER_ID,
        session_id=SESSION_ID
    )

    global runner
    runner = Runner(
        agent=root_agent,
        app_name=APP_NAME,
        session_service=session_service,
        memory_service=memory_service
    )

@app.post("/ask")
async def ask_agent(req: QueryRequest):
    """
    Endpoint to send a query to the agent pipeline.
    """
    content = types.Content(role="user", parts=[types.Part(text=req.query)])
    # `runner.run()` is a generator, not a coroutine, so it should not be awaited.
    events = runner.run(user_id=USER_ID, session_id=SESSION_ID, new_message=content)

    responses = []
    for event in events:
        if event.is_final_response() and event.content and event.content.parts:
            responses.append(event.content.parts[0].text)

    # Await both the get_session and add_session_to_memory calls.
    session = await session_service.get_session(app_name=APP_NAME, user_id=USER_ID, session_id=SESSION_ID)
    await memory_service.add_session_to_memory(session)

    return {"responses": responses or ["No response received."]}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Run & Demo

Run backend (agent.py):

$  uvicorn agent:app --host 0.0.0.0 --port 8000
Invalid config for agent TopicSetterAgent: output_schema cannot co-exist with agent transfer configurations. Setting disallow_transfer_to_parent=True, disallow_transfer_to_peers=True
INFO:     Started server process [17790]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
INFO:     127.0.0.1:45096 - "POST /ask HTTP/1.1" 200 OK

Run frontend (app.py):

$ python3 -m streamlit run app.py

  You can now view your Streamlit app in your browser.

  Local URL: http://localhost:8501
  Network URL: http://172.28.246.163:8501

Test Prompt:

I want to research about the "LLM Agents"

Topic_setter agent gives following response:

{"subtopic_1": "Definition and architecture of LLM Agents", 
"subtopic_2": "Applications and use cases of LLM Agents", 
"subtopic_3": "Challenges and future directions for LLM Agents"}

Research Agent1 gives response:

LLM agents face challenges including hallucinations, limited memory and 
context windows, and struggles with real-time decision-making and complex 
calculations. Future directions involve developing hybrid systems 
combining LLMs with deterministic tools for precision tasks, improving 
continuous learning and scalability, and enhancing multi-agent 
collaboration and ethical considerations.

Research Agent2:

LLM agents are advanced AI systems that use large language models (LLMs) 
to reason through problems, create plans, and execute tasks with the help 
of various tools, going beyond simple text generation to handle complex, 
multi-step assignments autonomously. Their architecture typically includes 
a core LLM (the "brain"), memory modules for retaining context, tools for 
external interactions (like APIs or databases), and planning components to 
break down complex tasks and determine actions.

Research Agent3:

LLM agents are utilized across various industries and applications due to 
their ability to understand language, perform complex tasks, and interact 
with external tools and data sources. Key applications include enhancing 
customer service through personalized interactions and 24/7 support, and 
streamlining internal operations such as HR and IT support. They also play 
a significant role in automating tasks like market analysis, financial 
reporting, supply chain management, and compliance checks by gathering and 
evaluating vast amounts of data. Furthermore, LLM agents are valuable in 
software development for generating code and assisting with debugging, and 
in research and development for hypothesis testing and data analysis.

Merger Agent:

Definition and architecture of LLM Agents
LLM agents are advanced AI systems that use large language models (LLMs) 
to reason through problems, create plans, and execute tasks with the help 
of various tools, going beyond simple text generation to handle complex, 
multi-step assignments autonomously. Their architecture typically includes 
a core LLM (the "brain"), memory modules for retaining context, tools for 
external interactions (like APIs or databases), and planning components to 
break down complex tasks and determine actions.

Applications and use cases of LLM Agents
LLM agents are utilized across various industries and applications due to 
their ability to understand language, perform complex tasks, and interact 
with external tools and data sources. Key applications include enhancing 
customer service through personalized interactions and 24/7 support, and 
streamlining internal operations such as HR and IT support. They also play 
a significant role in automating tasks like market analysis, financial 
reporting, supply chain management, and compliance checks by gathering and 
evaluating vast amounts of data. Furthermore, LLM agents are valuable in 
software development for generating code and assisting with debugging, and 
in research and development for hypothesis testing and data analysis.

Challenges and future directions for LLM Agents
LLM agents face challenges including hallucinations, limited memory and 
context windows, and struggles with real-time decision-making and complex 
calculations. Future directions involve developing hybrid systems 
combining LLMs with deterministic tools for precision tasks, improving 
continuous learning and scalability, and enhancing multi-agent 
collaboration and ethical considerations.

Conclusion
LLM agents represent a significant advancement in AI, enabling autonomous 
execution of complex, multi-step tasks by integrating LLMs with planning, 
memory, and external tools. While offering vast potential across diverse 
applications from customer service to software development, they currently 
grapple with issues like hallucinations and computational limitations. 
Future developments aim to overcome these challenges through hybrid 
architectures, enhanced learning capabilities, and robust ethical frameworks.

Demo GIF: GIF on GitHub

Conclusion

In this post, we mentioned:

how to access Google Gemini 2.5,
how to implement multi-agent parallel agents

For other posts 👉 https://dev.to/omerberatsezer 🧐

Follow for Tips, Tutorials, Hands-On Labs:

References

Your comments 🤔

Which tools are you using to develop AI Agents (e.g. Google ADK, AWS Strands, Google ADK, CrewAI, Langchain, etc.)?
What are you thinking about Google ADK?
Did you implement multi-agents using any framework (ADK, Strands, CrewAI)?

=> Welcome to any comments below related AI, agents for brainstorming 🤯

Multi-agents: Sequential Workflow using Google ADK 🤖 Gemini, Fast API, Streamlit - Create Game

Ömer Berat Sezer — Wed, 06 Aug 2025 06:33:32 +0000

In the past 4-5 months, TWO powerful AI agent development frameworks have been released:

Google Agent Development Kit (ADK)
AWS Strands Agents

You can view the other posts in the Google ADK series above. In our current post, we’ll dive into the Google Agent Development Kit (ADK) and show how to create workflow sequential agents (3 agents) using ADK, Gemini 2.5, FastAPI, and a Streamlit interface.

What is Google Agent Development Kit?
What is Multi-Agent, Workflow, Sequential Agents?
Agent App
- Installing Dependencies & Reaching Gemini Model
- Frontend - Streamlit UI
- Backend - Agent
- Run & Demo: To create Game
Conclusion
References

What is Google Agent Development Kit?

Agent Development Kit (ADK) is an open-source framework to develop AI agents to run anywhere:
- VSCode, Terminal,
- Docker Container
- Google CloudRun
- Kubernetes

What is Multi-Agent, Workflow, Sequential Agents?

The SequentialAgent is a workflow agentthat executes its sub-agents in the order they are specified in the list. Use the SequentialAgent when you want the execution to occur in a fixed, strict order.

When the SequentialAgent's Run Async method is called, it performs the following actions:

Iteration: It iterates through the sub agents list in the order they were provided.
Sub-Agent Execution: For each sub-agent in the list, it calls the sub-agent's Run Async method.

Details: https://google.github.io/adk-docs/agents/workflow-agents/sequential-agents/

Agent App

Sample project on GitHub:

https://github.com/omerbsezer/Fast-LLM-Agent-MCP/tree/main/agents/google_adk/06-multiagent-workflow-sequential

Installing Dependencies & Reaching Gemini Model

Go to: https://aistudio.google.com/
Get API key to reach Gemini
Please add .env with Gemini and Serper API Keys

# .env
GOOGLE_GENAI_USE_VERTEXAI=FALSE
GOOGLE_API_KEY=PASTE_YOUR_ACTUAL_API_KEY_HERE

Please install requirements:

fastapi
uvicorn
google-adk
google-generativeai

Frontend - Streamlit UI

# app.py
import streamlit as st
import requests

st.set_page_config(page_title="Agent Chat", layout="centered")

if "messages" not in st.session_state:
    st.session_state.messages = []

st.title("Multi-Agent Sequential")

for msg in st.session_state.messages:
    with st.chat_message(msg["role"]):
        st.markdown(msg["content"])

user_query = st.chat_input("Ask to search for real-time data or anything...")

# send and display user + assistant messages
if user_query:
    st.chat_message("user").markdown(user_query)
    st.session_state.messages.append({"role": "user", "content": user_query})
    try:
        response = requests.post(
            "http://localhost:8000/ask",
            json={"query": user_query}
        )
        response.raise_for_status()
        # respond is not str, it is list, because of multiple agent responds.
        all_replies = response.json().get("responses", ["No response."])

        for reply in all_replies:
            st.chat_message("assistant").markdown(reply)
            st.session_state.messages.append({"role": "assistant", "content": reply})

    except Exception as e:
        error_msg = f"Error: {str(e)}"
        st.chat_message("assistant").markdown(error_msg)
        st.session_state.messages.append({"role": "assistant", "content": error_msg})

Backend - Agent

# agent.py
from fastapi import FastAPI
from pydantic import BaseModel
from dotenv import load_dotenv
from google.genai import types
from google.adk.agents import Agent
from google.adk.agents.llm_agent import LlmAgent
from google.adk.agents.sequential_agent import SequentialAgent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService, Session
from google.adk.memory import InMemoryMemoryService


load_dotenv()

MODEL = "gemini-2.5-flash" 

APP_NAME = "search_memory_app"
USER_ID = "user123"
SESSION_ID = "session123"

# Code Writer Agent
# Takes the initial specification (from user query) and writes code.
code_writer_agent = LlmAgent(
    name="CodeWriterAgent",
    model=MODEL,
    instruction="""You are a Python Code Generator.
    Based *only* on the user's request, write Python code that fulfills the requirement.
    Output *only* the complete Python code block, enclosed in triple backticks (```

python ...

 ```). 
    Do not add any other text before or after the code block.
    """,
    description="Writes initial Python code based on a specification.",
    output_key="generated_code" # Stores output in state['generated_code']
)

# Code Reviewer Agent
# Takes the code generated by the previous agent (read from state) and provides feedback.
code_reviewer_agent = LlmAgent(
    name="CodeReviewerAgent",
    model=MODEL,
    instruction="""You are an expert Python Code Reviewer. 
    Your task is to provide constructive feedback on the provided code.

    **Code to Review:**
    ```

python
    {generated_code}


    ```

    **Review Criteria:**
    1.  **Correctness:** Does the code work as intended? Are there logic errors?
    2.  **Readability:** Is the code clear and easy to understand? Follows PEP 8 style guidelines?
    3.  **Efficiency:** Is the code reasonably efficient? Any obvious performance bottlenecks?
    4.  **Edge Cases:** Does the code handle potential edge cases or invalid inputs gracefully?
    5.  **Best Practices:** Does the code follow common Python best practices?

    **Output:**
    Provide your feedback as a concise, bulleted list. Focus on the most important points for improvement.
    If the code is excellent and requires no changes, simply state: "No major issues found."
    Output *only* the review comments or the "No major issues" statement.
    """,
    description="Reviews code and provides feedback.",
    output_key="review_comments", # Stores output in state['review_comments']
)


# Code Refactorer Agent
# Takes the original code and the review comments (read from state) and refactors the code.
code_refactorer_agent = LlmAgent(
    name="CodeRefactorerAgent",
    model=MODEL,
    instruction="""You are a Python Code Refactoring AI.
    Your goal is to improve the given Python code based on the provided review comments.

    **Original Code:**
    ```

python
    {generated_code}


    ```

    **Review Comments:**
    {review_comments}

    **Task:**
    Carefully apply the suggestions from the review comments to refactor the original code.
    If the review comments state "No major issues found," return the original code unchanged.
    Ensure the final code is complete, functional, and includes necessary imports and docstrings.

    **Output:**
    Output *only* the final, refactored Python code block, enclosed in triple backticks (```

python ...

 ```). 
    Do not add any other text before or after the code block.
    """,
    description="Refactors code based on review comments.",
    output_key="refactored_code", # Stores output in state['refactored_code']
)


# This agent orchestrates the pipeline by running the sub_agents in order.
code_pipeline_agent = SequentialAgent(
    name="CodePipelineAgent",
    sub_agents=[code_writer_agent, code_reviewer_agent, code_refactorer_agent],
    description="Executes a sequence of code writing, reviewing, and refactoring.",
    # The agents will run in the order provided: Writer -> Reviewer -> Refactorer
)

root_agent = code_pipeline_agent

session_service = InMemorySessionService()
memory_service = InMemoryMemoryService()

app = FastAPI()

class QueryRequest(BaseModel):
    query: str

@app.on_event("startup")
async def startup_event():
    await session_service.create_session(
        app_name=APP_NAME,
        user_id=USER_ID,
        session_id=SESSION_ID
    )

    global runner 
    runner = Runner(
        agent=root_agent,
        app_name=APP_NAME,
        session_service=session_service,
        memory_service=memory_service
    )    

@app.post("/ask")
def ask_agent(req: QueryRequest):
    content = types.Content(role="user", parts=[types.Part(text=req.query)])
    events = runner.run(user_id=USER_ID, session_id=SESSION_ID, new_message=content)

    responses = []
    for event in events:
        if event.is_final_response() and event.content and event.content.parts:
            responses.append(event.content.parts[0].text)

    # Save session to memory after each turn
    session = session_service.get_session(app_name=APP_NAME, user_id=USER_ID, session_id=SESSION_ID)
    memory_service.add_session_to_memory(session)

    return {"responses": responses or ["No response received."]}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Run & Demo

Run backend (agent.py):

$ uvicorn agent:app --host 0.0.0.0 --port 8000
INFO:     Started server process [5037]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

Run frontend (app.py):

$ python3 -m streamlit run app.py
  You can now view your Streamlit app in your browser.

  Local URL: http://localhost:8501
  Network URL: http://172.28.246.163:8501

Test Prompt:

I want to create a space shuttle game where meteors fall from the top of 
the screen. The player controls the shuttle using the arrow keys and can 
shoot at the meteors by pressing the spacebar.

Code Generator agent created code, Reviwer agent gives following response:

- Game Over Event Handling: The event loop for quitting (for event in 
pygame.event.get():) inside the if game_over: block is problematic. 
pygame.event.get() consumes all events in the queue. Calling it twice 
(once in the main loop, once in the game_over block) means the inner loop 
might miss events already processed by the outer loop or only catch events 
that occurred after the outer loop for that frame. It's better to handle 
all events in the main loop and apply conditions based on game_over. For 
example, change if event.key == pygame.K_q: within the inner loop to elif 
event.key == pygame.K_q and game_over: in the main event loop.

- Magic Numbers/Constants: Many literal values (e.g., 50 for shuttle size, 
7 for speed, 10 for score, 1000 for meteor spawn time) are used directly 
in the code. Defining these as named constants at the top would improve 
readability, make them easier to modify, and reduce potential errors.

- Player Vertical Movement Limit: The SCREEN_HEIGHT // 2 boundary for the 
player's vertical movement is an arbitrary "magic number". If this is a 
design choice, consider making it a named constant (e.g., 
PLAYER_TOP_BOUND) for clarity.

- Visuals: While functional for a prototype, the game uses simple colored 
squares. In a more complete game, consider loading actual image assets for 
the shuttle, meteors, and bullets for a better visual experience.

Code Refactor Agent fixes the code: Generated-Codes on GitHub

Space Shuttle Game:

Demo GIF: GIF on GitHub

Conclusion

In this post, we mentioned:

how to access Google Gemini 2.5,
how to implement multi-agent sequential worfklow

For other posts 👉 https://dev.to/omerberatsezer 🧐

Follow for Tips, Tutorials, Hands-On Labs:

References

Your comments 🤔

Which tools are you using to develop AI Agents (e.g. Google ADK, AWS Strands, Google ADK, CrewAI, Langchain, etc.)?
What are you thinking about Google ADK?
Did you implement multi-agent, workflow before?

=> Welcome to any comments below related AI, agents for brainstorming 🤯

Agent with Memory, BuiltIn Search, LiteLLM using Google Agent Development Kit 🤖 Gemini, Fast API, Streamlit 🗃

Ömer Berat Sezer — Wed, 25 Jun 2025 06:18:44 +0000

In the past three months, TWO powerful AI agent development frameworks have been released:

Google Agent Development Kit (ADK)
AWS Strands Agents

Previously, we implemented with Google Agent Development Kit and learn how to create agent-based applications using local and remote MCP (Model Context Protocol) tools alongside Gemini, FastAPI, and a Streamlit.

Also, we've introduced AWS Strands Agent, and how to implement agent to use local and remote MCP tools in this POST.

In our current post, we’ll dive into the Google Agent Development Kit (ADK) and show how to create agent-based applications with Memory (long-term), Built-In Google Search Tool, and using different LLMs (Bedrock, OpenAI, Ollama, etc,) using Gemini 2.5, FastAPI, and a Streamlit interface.

What is Google Agent Development Kit?
Motivation: Why Use an Agent Framework?
ADK Session, Memory Implementation
Agent App with Memory, LiteLLM using Google ADK, Gemini, FastAPI and Streamlit
- Agent with Memory
- Agent with Different LLM Models
- Agent with BuiltIn Search Tool
- Installing Dependencies & Reaching Gemini Model
- Frontend - Streamlit UI
- Backend for Memory App, Built-in Google Search Tool
- Agent with Memory, Run & Demo
- Backend for LiteLLM (for different LLM models)
- Agent with LiteLLM, Run & Demo
Conclusion
References

What is Google Agent Development Kit?

Agent Development Kit (ADK) is an open-source framework to develop AI agents to run anywhere:
- VSCode, Terminal,
- Docker Container
- Google CloudRun
- Kubernetes

Motivation: Why Use an Agent Framework?

Structured workflows: Automates decision-making, tool use, and response generation in a clear loop.
Session & memory support: Keeps context across interactions for smarter, personalized behavior.
Multi-agent orchestration: Lets specialized agents collaborate on complex tasks.
Tool integration: Easily plug in MCP tools, APIs, functions that agents know when and how to use them.
Multi-model flexibility: Use and switch between different LLMs (e.g. GPT, Claude, Nova).
Production-ready: Built-in logging, monitoring, and error handling for real-world use.

ADK Session, Memory Implementation

We've explored how a session keeps track of the history (events) and temporary state within a single ongoing conversation. But what happens when an agent needs to remember details from earlier conversations or tap into external knowledge sources? That’s where Long-Term Knowledge and the MemoryService become essential.

Session / State: Like your short-term memory during one specific chat.
Long-Term Knowledge (MemoryService): Like a searchable archive or knowledge library the agent can consult, potentially containing information from many past chats or other sources.

ADK provides services to manage these concepts:

SessionService: Manages the different conversation threads (Session objects)
- Handles the lifecycle: creating, retrieving, updating (appending Events, modifying State), and deleting individual Sessions.
MemoryService: Manages the Long-Term Knowledge Store (Memory)
- Handles ingesting information (often from completed Sessions) into the long-term store. Provides methods to search this stored knowledge based on queries.

ADK provides different ways to implement this long-term knowledge store:

InMemoryMemoryService:
- How it works: Stores session information in the application's memory and performs basic keyword matching for searches.
- Persistence: None. All stored knowledge is lost if the application restarts.
- Requires: Nothing extra.
- Best for: Prototyping, simple testing, scenarios where only basic keyword recall is needed and persistence isn't required.
VertexAiRagMemoryService:
- How it works: Leverages Google Cloud's Vertex AI RAG (Retrieval-Augmented Generation) service. It ingests session data into a specified RAG Corpus and uses powerful semantic search capabilities for retrieval.
- Persistence: Yes. The knowledge is stored persistently within the configured Vertex AI RAG Corpus.
- Requires: A Google Cloud project, appropriate permissions, necessary SDKs (pip install google-adk[vertexai]), and a pre-configured Vertex AI RAG Corpus resource name/ID.
- Best for: Production applications needing scalable, persistent, and semantically relevant knowledge retrieval, especially when deployed on Google Cloud.

Agent App with Memory, LiteLLM using Google ADK, Gemini, FastAPI and Streamlit

TWO small sample projects on GitHub:

Agent with Memory

To store data while running with InMemoryMemoryService().

from google.adk.agents import Agent
from google.adk.sessions import InMemorySessionService, Session
from google.adk.memory import InMemoryMemoryService

session_service = InMemorySessionService()
memory_service = InMemoryMemoryService()

...
runner = Runner(
    agent=agent,
    app_name=APP_NAME,
    session_service=session_service,
    memory_service=memory_service
)

Agent with Different LLM Models

To use different LLM models using LiteLLM ("bedrock/meta.llama3-1-405b-instruct-v1:0").

from google.adk.agents import Agent
from google.adk.models.lite_llm import LiteLlm

Agent(
    model=LiteLlm(model="bedrock/meta.llama3-1-405b-instruct-v1:0"),
    # model=LiteLlm(model="ollama/llama3.2:1b"),
    name="bedrock_agent",
    instruction=instruction
)

Agent with BuiltIn Search Tool

To use builtin Google Search tools (google_search) instead of using other tools like MCP Serper, Tavily.

from google.adk.tools import load_memory, google_search
from google.adk.agents import Agent

Agent(
    model=MODEL,
    name="google_search_agent",
    instruction=instruction,
    tools=[google_search],
)

Installing Dependencies & Reaching Gemini Model

Go to: https://aistudio.google.com/
Get API key to reach Gemini
Please add .env with Gemini and Serper API Keys

# .env
SERPER_API_KEY=PASTE_YOUR_ACTUAL_API_KEY_HERE
GOOGLE_GENAI_USE_VERTEXAI=FALSE
GOOGLE_API_KEY=PASTE_YOUR_ACTUAL_API_KEY_HERE

Please install nodejs, npm, npx in your system to run npx-based MCP tool.
Please install requirements:

fastapi
uvicorn
google-adk
google-generativeai

Frontend - Streamlit UI

# app.py
import streamlit as st
import requests

st.set_page_config(page_title="Agent Chat", layout="centered")

if "messages" not in st.session_state:
    st.session_state.messages = []

st.title("Agent Memory, LiteLLM")

for msg in st.session_state.messages:
    with st.chat_message(msg["role"]):
        st.markdown(msg["content"])

user_query = st.chat_input("Ask to search for real-time data or anything...")

# send and display user + assistant messages
if user_query:
    st.chat_message("user").markdown(user_query)
    st.session_state.messages.append({"role": "user", "content": user_query})
    try:
        response = requests.post(
            "http://localhost:8000/ask",
            json={"query": user_query}
        )
        response.raise_for_status()
        agent_reply = response.json().get("response", "No response.")
    except Exception as e:
        agent_reply = f"Error: {str(e)}"

    st.chat_message("assistant").markdown(agent_reply)
    st.session_state.messages.append({"role": "assistant", "content": agent_reply})

Backend for Memory App, Built-in Google Search Tool

# agent.py
from fastapi import FastAPI
from pydantic import BaseModel
from dotenv import load_dotenv
from google.genai import types
from google.adk.agents import Agent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService, Session
from google.adk.memory import InMemoryMemoryService
from google.adk.tools import load_memory, google_search
load_dotenv()

# --- App/Session Config ---
APP_NAME = "search_memory_app"
USER_ID = "user123"
SESSION_ID = "session123"

MODEL = "gemini-2.5-flash-preview-04-17"
#MODEL="gemini-2.0-flash"

def create_agent() -> Agent:
    instruction = (
        "You are a helpful assistant. Search with 'google_search'."
    )
    return Agent(
        model=MODEL,
        name="google_search_agent",
        instruction=instruction,
        tools=[google_search],
    )

# --- Init Services ---
session_service = InMemorySessionService()
memory_service = InMemoryMemoryService()

# Create session once
session_service.create_session(
    app_name=APP_NAME,
    user_id=USER_ID,
    session_id=SESSION_ID
)

agent = create_agent()
runner = Runner(
    agent=agent,
    app_name=APP_NAME,
    session_service=session_service,
    memory_service=memory_service
)

app = FastAPI()

class QueryRequest(BaseModel):
    query: str

@app.post("/ask")
def ask_agent(req: QueryRequest):
    content = types.Content(role="user", parts=[types.Part(text=req.query)])
    events = runner.run(user_id=USER_ID, session_id=SESSION_ID, new_message=content)

    final_response = "No response received."
    for event in events:
        if event.is_final_response() and event.content and event.content.parts:
            final_response = event.content.parts[0].text
            break

    # Save session to memory after each turn
    session = session_service.get_session(app_name=APP_NAME, user_id=USER_ID, session_id=SESSION_ID)
    memory_service.add_session_to_memory(session)

    return {"response": final_response}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Agent with Memory, Run & Demo

Run frontend (app.py):

streamlit run app.py
or
python -m streamlit run app.py

Run backend (agent.py):

uvicorn agent:app --host 0.0.0.0 --port 8000

Agent With Memory Demo: GIF on GitHub

Agent WithOUT Memory Demo: GIF on GitHub

Backend for LiteLLM (for different LLM models)

AWS Bedrock and Ollama models can be reached using LiteLLM.

# agent.py
from fastapi import FastAPI
from pydantic import BaseModel
from dotenv import load_dotenv
from google.genai import types
from google.adk.agents import Agent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService, Session
from google.adk.models.lite_llm import LiteLlm
import boto3

load_dotenv()

APP_NAME = "search_memory_app"
USER_ID = "user123"
SESSION_ID = "session123"

## AWS Sample with Bedrock, one-by-one enable
def create_agent() -> Agent:
    instruction = (
        "You are a helpful assistant."
    )
    return Agent(
        model=LiteLlm(model="bedrock/meta.llama3-1-405b-instruct-v1:0"),
        name="bedrock_agent",
        instruction=instruction
    )

## Ollma Sample, one-by-one enable
# def create_agent() -> Agent:
#     instruction = (
#         "You are a helpful assistant."
#     )
#     return Agent(
#         model=LiteLlm(model="ollama/llama3.2:1b"),
#         name="ollama_agent",
#         instruction=instruction
#     )

session_service = InMemorySessionService()

session_service.create_session(
    app_name=APP_NAME,
    user_id=USER_ID,
    session_id=SESSION_ID
)

agent = create_agent()
runner = Runner(
    agent=agent,
    app_name=APP_NAME,
    session_service=session_service
)

app = FastAPI()

class QueryRequest(BaseModel):
    query: str

@app.post("/ask")
def ask_agent(req: QueryRequest):
    content = types.Content(role="user", parts=[types.Part(text=req.query)])
    events = runner.run(user_id=USER_ID, session_id=SESSION_ID, new_message=content)

    final_response = "No response received."
    for event in events:
        if event.is_final_response() and event.content and event.content.parts:
            final_response = event.content.parts[0].text
            break

    # Save session to memory after each turn
    session = session_service.get_session(app_name=APP_NAME, user_id=USER_ID, session_id=SESSION_ID)

    return {"response": final_response}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Agent with LiteLLM, Run & Demo

Run frontend (app.py):

streamlit run app.py
or
python -m streamlit run app.py

Run backend (agent.py):

uvicorn agent:app --host 0.0.0.0 --port 8000

AWS Bedrock Demo: GIF on GitHub

Ollama Demo On-Prem: GIF on GitHub

Conclusion

In this post, we mentioned:

how to access Google Gemini 2.5,
how to implement Google ADK agent with Memory,
how to use/bind Built-In Google Search Tool to the agent,
how to implement Google ADK agent to use different LLMs with LiteLLM (Bedrock, Ollama) using Gemini, Fast API, Streamlit UI.

For other posts 👉 https://dev.to/omerberatsezer 🧐

Follow for Tips, Tutorials, Hands-On Labs:

References

Your comments 🤔

Which tools are you using to develop AI Agents (e.g. Google ADK, AWS Strands, Google ADK, CrewAI, Langchain, etc.)?
What are you thinking about Google ADK?
Did you test to implement Memory before?

=> Welcome to any comments below related AI, agents for brainstorming 🤯

Agent with Local, Remote MCP Tools using AWS Strands Agents 🧬 Bedrock, Nova, Fast API, Streamlit

Ömer Berat Sezer — Wed, 18 Jun 2025 08:10:34 +0000

Many major tech companies have declared this year as the Year of AI Agents. Additionally, several new agent development frameworks have been released in the past three months. In the past three months, TWO powerful AI agent development frameworks have been released:

AWS Strands Agents
Google Agent Development Kit (ADK)

Previous post was related agent sample code with Google ADK to implement remote & local MCP.

This time, we're diving to AWS Strands way.. In both frameworks, when implementing in the same scenario, even if some parts look the same, there are certain differences in approach (e.g. session, runners)

In this post, we’ll explore what the AWS Strands Agent is and how you can build an end-to-end app with remote and local MCP (Model Context Protocol)tools using Strands, Bedrock, Nova, FastAPI, and a Streamlit UI.

What is AWS Strands Agents?
Motivation: Why Use an Agent Framework?
Agent Loop with Tools
What is Model Context Protocol (MCP)?
Agent App with Local & Remote MCP using Strands, Nova, FastAPI and Streamlit
- Installing Dependencies & Reaching LLM Model
- Frontend - Streamlit UI
- Backend Local MCP
- Local MCP Run & Demo
- Backend Remote MCP
- Remote MCP Run & Demo
Conclusion
References

What is AWS Strands Agents?

Strands agent is an open-source framework to develop AI agents to run anywhere:
- VSCode, Terminal,
- Docker Container
- AWS Lambda
- AWS ECS (Elastic Container Service)
- AWS EKS (Elastic Kubernetes Service)
Well documentation to view/learn agents, tools, workflows, memory, multi agents, etc.
- https://strandsagents.com/

Motivation: Why Use an Agent Framework?

Structured workflows: Automates decision-making, tool use, and response generation in a clear loop.
Session & memory support: Keeps context across interactions for smarter, personalized behavior.
Multi-agent orchestration: Lets specialized agents collaborate on complex tasks.
Tool integration: Easily plug in MCP tools, APIs, functions that agents know when and how to use them.
Multi-model flexibility: Use and switch between different LLMs (e.g. GPT, Claude, Nova).
Production-ready: Built-in logging, monitoring, and error handling for real-world use.

Agent Loop

The agent loop is the mechanism through which a Strands agent interprets user input, makes decisions, uses tools, and produces responses. It enables advanced, multi-step reasoning and actions by tightly integrating tools with language models..

Fundamentally, the agent loop operates through the following steps:

Receives user input and contextual information,
Processes the input using a language model (LLM),
Decides whether to use tools to gather information or perform actions,
Executes tools and receives results,
Continues reasoning with the new information,
Produces a final response or iterates again through the loop.

This cycle can occur several times during a single user interaction, enabling the agent to carry out intricate, multi-step reasoning and act autonomously.

What is Model Context Protocol (MCP)?

MCP is an open standard designed to standardize how Large Language Models (LLMs) communicate with external applications, data sources, and tools.

Agent App with Local & Remote MCP using AWS Strands, Nova, FastAPI and Streamlit

TWO small sample projects with MCPs on GitHub using AWS-Strands:

Local MCP Tool - FileOps

FileOps MCP runs on Linux (WSL). Please install nodejs, npm, npx in your system to run npx-based MCP tool.

Remote MCP Tool - Serper

Loging into the Serper App and Serper API key is required to run Serper MCP tool. Also, please install nodejs, npm, npx in your system to run npx-based MCP tool.

Installing Dependencies & Reaching Gemini Model

Please install AWS Strands Agents & Tools libraries:

pip install strands-agents
pip install strands-agents-tools strands-agents-builder

Enable AWS Bedrock model access in your region or US-West-2
- AWS Bedrock > Bedrock Configuration > Model Access > AWS Nova-Pro, or Claude 3.7 Sonnet, or Llama 4
In this code, we'll use AWS Nova-Pro, because it's served in different regions by AWS.
After model access, give permission in your IAM to access AWS Bedrock services: AmazonBedrockFullAccess
2 Options to reach AWS Bedrock Model using your AWS account:
- AWS Config: With aws configure, to create configand credentials files
- Getting variables using .env file: Add .env file:

AWS_ACCESS_KEY_ID= PASTE_YOUR_ACCESS_KEY_ID_HERE
AWS_SECRET_ACCESS_KEY=PASTE_YOUR_SECRET_ACCESS_KEY_HERE

Frontend - Streamlit UI

# app.py
import streamlit as st
import requests
import json 

st.set_page_config(page_title="AWS Strands Agent Chat", layout="centered")

st.title("AWS Strands Agent MCP")

# initialize chat history
if "messages" not in st.session_state:
    st.session_state.messages = []

user_query = st.chat_input("Ask for system file tool commands or anything...")

if user_query:
    st.session_state.messages.append({"role": "user", "content": user_query})

    try:
        response = requests.post("http://localhost:8000/ask", json={"query": user_query})
        response.raise_for_status()

        response_json = response.json()
        assistant_text = response_json["response"]["message"]["content"][0]["text"]

    except Exception as e:
        assistant_text = f"Error: {str(e)}"

    st.session_state.messages.append({"role": "assistant", "content": assistant_text})

# display all messages in order
for msg in st.session_state.messages:
    st.chat_message(msg["role"]).markdown(msg["content"])

Backend Local MCP

# agent.py
import asyncio
from contextlib import asynccontextmanager, AsyncExitStack
from fastapi import FastAPI, Request
from pydantic import BaseModel
from strands import Agent
from strands.models import BedrockModel
from strands.tools.mcp import MCPClient
from mcp import stdio_client, StdioServerParameters

MODEL = "us.amazon.nova-pro-v1:0"
MCP_TOOL_PATH = "/home/omer/mcp-test"

bedrock_model = BedrockModel(
    model_id=MODEL,
    temperature=0.3,
    top_p=0.8,
)

agent = None
mcp_client = None

@asynccontextmanager
async def lifespan(app: FastAPI):
    global agent, mcp_client

    async with AsyncExitStack() as stack:
        mcp_client = MCPClient(lambda: stdio_client(
            StdioServerParameters(
                command="npx",
                args=["-y", "@modelcontextprotocol/server-filesystem", MCP_TOOL_PATH],
            )
        ))

        stack.enter_context(mcp_client)

        tools = mcp_client.list_tools_sync()
        agent = Agent(
            model=bedrock_model,
            system_prompt=(
                "Help user interact with the local filesystem using available tools. "
                "Fallback to LLM knowledge if necessary."
            ),
            tools=tools
        )

        yield

app = FastAPI(lifespan=lifespan)

class QueryRequest(BaseModel):
    query: str

@app.post("/ask")
async def ask(request: Request):
    data = await request.json()
    query = data.get("query", "")
    try:
        response = agent(query, stream=False)
        return {"response": response}
    except Exception as e:
        return {"error": str(e)}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run("agent:app", host="0.0.0.0", port=8000)

Local MCP Run & Demo

Run frontend (app.py):

streamlit run app.py
or
python -m streamlit run app.py

Run backend (agent.py):

uvicorn agent:app --host 0.0.0.0 --port 8000

Demo: GIF on GitHub

Backend Remote MCP

# agent.py
import asyncio
from contextlib import asynccontextmanager, AsyncExitStack
from fastapi import FastAPI, Request
from pydantic import BaseModel
from dotenv import load_dotenv
from strands import Agent
from strands.models import BedrockModel
from strands.tools.mcp import MCPClient
from mcp import stdio_client, StdioServerParameters
import os

load_dotenv()

MODEL = "us.amazon.nova-pro-v1:0"

bedrock_model = BedrockModel(
    model_id=MODEL,
    temperature=0.3,
    top_p=0.8,
)

agent = None
mcp_client = None
serper_api_key = os.getenv("SERPER_API_KEY")

@asynccontextmanager
async def lifespan(app: FastAPI):
    global agent, mcp_client

    async with AsyncExitStack() as stack:

        mcp_client = MCPClient(lambda: stdio_client(
            StdioServerParameters(
                command='npx',
                args=["-y", "serper-search-scrape-mcp-server"],
                env={"SERPER_API_KEY": serper_api_key}
            )
        ))

        stack.enter_context(mcp_client)

        tools = mcp_client.list_tools_sync()
        agent = Agent(
            model=bedrock_model,
            system_prompt=(
                """You are a research assistant and search on SERPER, search and give results in link, title, content
                'You MUST:
                - Use **google_search** to perform web searches when the user is asking for general information, how-to guides, comparisons, news, or any content that could be sourced from the internet. This tool retrieves:
                    - Perform web searches using user queries to find organic results, FAQs, related searches, and knowledge graph entries.
                    - Handle a wide range of search intents: informational, comparative, educational, technical, current events, etc.
                    - Always return useful summaries along with links to the most relevant pages.
                **Tool Parameters**
                    - `q`: Required. The search query string (e.g., "how Kubernetes works", "latest AI trends 2025"). Retrieve from the prompt.
                    - `gl`: Required. Geographic region code in ISO 3166-1 alpha-2 format (e.g., "us", "de", "gb"). Use "en".
                    - `hl`: Required. Language code in ISO 639-1 format (e.g., "en", "fr", "es"). Use "en.
                    - `location`: Required. Location for search results (e.g., 'SoHo, New York, United States', 'California, United States'). Use "United States".
                Always summarize the top results clearly and include direct URLs for reference.
                - Use **scrape** to extract content from a specific webpage when:
                    - The user provides a URL and asks for content, summaries, or metadata
                    - A relevant link was previously found via **google_search** and needs to be explored further
                - Use the tools wisely to assist users. Based on the provided results, use Function tool call returns, retrieve only content.  
                - Parse the JSON response carefully and extract **relevant fields**. Give the search results with TITLE, LINK, CONTENT or SNIPPET.
                - For all other questions, respond using your own knowledge."""
            ),
            tools=tools
        )

        yield

app = FastAPI(lifespan=lifespan)

class QueryRequest(BaseModel):
    query: str

@app.post("/ask")
async def ask(request: Request):
    data = await request.json()
    query = data.get("query", "")
    try:
        response = agent(query, stream=False)
        return {"response": response}
    except Exception as e:
        return {"error": str(e)}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run("agent:app", host="0.0.0.0", port=8000)

Remote MCP Run & Demo

Run frontend (app.py):

streamlit run app.py
or
python -m streamlit run app.py

Run backend (agent.py):

uvicorn agent:app --host 0.0.0.0 --port 8000

Demo: GIF on GitHub

Conclusion

In this post, we mentioned:

how to access AWS Bedrock Foundation Models,
how to implement AWS Strands agent with remote & local MCP tools using AWS Bedrock (Serverless), AWS Nova-Pro LLM, Fast API, Streamlit UI.

For other posts 👉 https://dev.to/omerberatsezer 🧐

For Tips, Tutorials, Hands-On Labs:

References

Your comments 🤔

Which tools are you using to develop AI Agents (e.g. AWS Strands, Google ADK, CrewAI, Langchain, etc.)? Please mention in the comment your experience, your interest?
What are you thinking about AWS Strands Agent?
What are your thoughts and experiences with MCP tools?
What areas of LLM and agent development are you most interested in learning?

=> Welcome to any comments below related AI, agents for brainstorming 🤯

What is Google Agent Development Kit? 🤖 Agent with Local, Remote MCP Tools using ADK, Gemini, Fast API, Streamlit 🔧

Ömer Berat Sezer — Wed, 11 Jun 2025 07:19:18 +0000

In the past three months, TWO powerful AI agent development frameworks have been released:

Google Agent Development Kit (ADK)
AWS Strands Agents

In the previous post, we've introduces AWS Strands agent and app using AWS Strands Agent, Nova, FastAPI, Streamlit UI.

In this post, we’ll dive into the Google Agent Development Kit (ADK) and show how to create agent-based applications using local and remote MCP (Model Context Protocol) tools alongside Gemini 2.5, FastAPI, and a Streamlit interface. Whether you're interested in understanding how AI agents function or ready to build your own, this guide is a great place to begin.

What is Google Agent Development Kit?
Motivation: Why Use an Agent Framework?
Google ADK Agent Event Loop
What is Model Context Protocol (MCP)?
Agent App with Local & Remote MCP using Google ADK, Gemini, FastAPI and Streamlit
- Installing Dependencies & Reaching Gemini Model
- Frontend - Streamlit UI
- Backend Local MCP
- Local MCP Run & Demo
- Backend Remote MCP
- Remote MCP Run & Demo
Conclusion
References

What is Google Agent Development Kit?

Agent Development Kit (ADK) is an open-source framework to develop AI agents to run anywhere:
- VSCode, Terminal,
- Docker Container
- Google CloudRun
- Google Kubernetes Engine
Really good documentation to view/learn agents, tools, workflows, session, memory, runner, multi agents, etc.
- https://google.github.io/adk-docs/
Quickstart: https://google.github.io/adk-docs/get-started/quickstart/

Motivation: Why Use an Agent Framework?

Organized workflows: Make it easier decision-making, tool usage, and response generation through a structured process.
Contextual memory: Maintains session history to enable more intelligent and personalized interactions.
Collaborative agents: Coordinates multiple specialized agents to handle complex problems effectively.
Seamless tool integration: Supports connecting tools, APIs, and functions that agents can invoke appropriately.
Model versatility: Enables use and switching between various language models (e.g., GPT, Claude, Nova).
Ready for deployment: Includes built-in capabilities for logging, monitoring, and robust error management.

Google ADK Agent Event Loop

At its heart, the ADK Runtime operates on an Event Loop. This loop facilitates a back-and-forth communication between the Runner component and your defined "Execution Logic" (which includes your Agents, the LLM calls they make, Callbacks, and Tools).

In simple terms:

The Runner receives a user query and asks the main Agent to start processing.
The Agent(and its associated logic) runs until it has something to report (like a response, a request to use a tool, or a state change) – it then yields or emits an Event.
The Runner receives this Event, processes any associated actions (like saving state changes via Services), and forwards the event onwards (e.g., to the user interface).
Only after the Runner has processed the event does the Agent's logic resume from where it paused, now potentially seeing the effects of the changes committed by the Runner.
This cycle repeats until the agent has no more events to yield for the current user query.

What is Model Context Protocol (MCP)?

MCP is an open standard designed to standardize how Large Language Models (LLMs) like Gemini and Claude communicate with external applications, data sources, and tools.

[TLDR]
MCP is middleware that connects LLM/Agent and Internet apps with their APIs

Agent App with Local & Remote MCP using Google ADK, Gemini, FastAPI and Streamlit

TWO small sample projects on GitHub:

Local MCP Tool - FileOps

FileOps MCP runs on Linux (WSL). Please install nodejs, npm, npx in your system to run npx-based MCP tool.

Remote MCP Tool - Serper

Loging into the Serper App and Serper API key is required to run Serper MCP tool. Also, please install nodejs, npm, npx in your system to run npx-based MCP tool.

Installing Dependencies & Reaching Gemini Model

Go to: https://aistudio.google.com/
Get API key to reach Gemini
Please add .env with Gemini and Serper API Keys

# .env
SERPER_API_KEY=PASTE_YOUR_ACTUAL_API_KEY_HERE
GOOGLE_GENAI_USE_VERTEXAI=FALSE
GOOGLE_API_KEY=PASTE_YOUR_ACTUAL_API_KEY_HERE

Please install nodejs, npm, npx in your system to run npx-based MCP tool.
Please install requirements:

fastapi
uvicorn
google-adk
google-generativeai
pydantic
streamlit
dotenv

Frontend - Streamlit UI

# app.py
import streamlit as st
import requests

st.set_page_config(page_title="Agent Chat", layout="centered")

if "messages" not in st.session_state:
    st.session_state.messages = []

st.title("Agent MCP Tool")

for msg in st.session_state.messages:
    with st.chat_message(msg["role"]):
        st.markdown(msg["content"])

user_query = st.chat_input("Ask for tool commands or anything...")

# send and display user + assistant messages
if user_query:
    st.chat_message("user").markdown(user_query)
    st.session_state.messages.append({"role": "user", "content": user_query})
    try:
        response = requests.post(
            "http://localhost:8000/ask",
            json={"query": user_query}
        )
        response.raise_for_status()
        agent_reply = response.json().get("response", "No response.")
    except Exception as e:
        agent_reply = f"Error: {str(e)}"

    st.chat_message("assistant").markdown(agent_reply)
    st.session_state.messages.append({"role": "assistant", "content": agent_reply})

Backend Local MCP

# agent.py
import asyncio
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from dotenv import load_dotenv
from google.genai import types
from google.adk.agents.llm_agent import LlmAgent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.adk.artifacts.in_memory_artifact_service import InMemoryArtifactService
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset, StdioServerParameters
from fastapi import FastAPI, Request


load_dotenv()

MODEL = "gemini-2.5-flash-preview-04-17" 
MCP_TOOL_PATH =  "/home/omer/mcp-test"
# # MODEL="gemini-2.5-pro-preview-03-25"
# # MODEL="gemini-2.0-flash"
# # MODEL="gemini-2.0-flash-lite"

app = FastAPI()

class QueryRequest(BaseModel):
    query: str

# MCPToolset.from_server(...) is an async likely performing I/O, so all chain async
async def get_agent_async():
    """Creates an ADK Agent equipped with tools from the MCP Server."""
    tools, exit_stack = await MCPToolset.from_server(
        connection_params=StdioServerParameters(
            command='npx',
            args=["-y", "@modelcontextprotocol/server-filesystem", MCP_TOOL_PATH],
        )
    )
    print(f"Fetched {len(tools)} tools from MCP server.")
    root_agent = LlmAgent(
        model=MODEL,
        name='filesystem_assistant',
        instruction='Help user interact with the local filesystem using available tools. \n'
        '- For all other questions, respond using your own knowledge.',
        tools=tools,
    )
    return root_agent, exit_stack


async def handle_query(query: str):
    session_service = InMemorySessionService()
    artifacts_service = InMemoryArtifactService()

    session = session_service.create_session(
        state={}, app_name='mcp_filesystem_app', user_id='user_fs'
    )

    content = types.Content(role='user', parts=[types.Part(text=query)])
    root_agent, exit_stack = await get_agent_async()

    runner = Runner(
        app_name='mcp_filesystem_app',
        agent=root_agent,
        artifact_service=artifacts_service,
        session_service=session_service,
    )

    events_async = runner.run_async(
        session_id=session.id, user_id=session.user_id, new_message=content
    )

    result = []
    async for event in events_async:
        if hasattr(event, "content") and event.content:
            for part in event.content.parts:
                if hasattr(part, "text") and part.text:
                    result.append(part.text)
        elif hasattr(event, "tool_name") and hasattr(event, "parameters"):
            result.append(f"Tool called: {event.tool_name}({event.parameters})")
        elif hasattr(event, "response"):
            result.append(f"Tool response: {event.response}")
        else:
            result.append(f"Unrecognized event: {event}")

    await exit_stack.aclose()

    final_output = "\n".join(result).strip()
    return final_output if final_output else "No response from model or tools."

@app.post("/ask")
async def ask(request: Request):
    data = await request.json()
    query = data.get("query", "")
    response = await handle_query(query)
    return {"response": response}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Local MCP Run & Demo

Run frontend (app.py):

streamlit run app.py
or
python -m streamlit run app.py

Run backend (agent.py):

uvicorn agent:app --host 0.0.0.0 --port 8000

Demo: GIF on GitHub

Backend Remote MCP

# agent.py
import asyncio
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from dotenv import load_dotenv
from google.genai import types
from google.adk.agents.llm_agent import LlmAgent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.adk.artifacts.in_memory_artifact_service import InMemoryArtifactService
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset, StdioServerParameters
from fastapi import FastAPI, Request
import os


load_dotenv()

MODEL = "gemini-2.5-flash-preview-04-17" 
# # MODEL="gemini-2.5-pro-preview-03-25"
# # MODEL="gemini-2.0-flash"
# # MODEL="gemini-2.0-flash-lite"

app = FastAPI()

class QueryRequest(BaseModel):
    query: str

# MCPToolset.from_server(...) is an async likely performing I/O, so all chain async
async def get_agent_async():
    """Creates an ADK Agent equipped with tools from the MCP Server."""
    serper_api_key = os.getenv("SERPER_API_KEY")
    tools, exit_stack = await MCPToolset.from_server(
        connection_params=StdioServerParameters(
            command='npx',
            args=["-y", "serper-search-scrape-mcp-server"],
            env={"SERPER_API_KEY": serper_api_key}
        )
    )
    print(f"Fetched {len(tools)} tools from MCP server.")
    root_agent = LlmAgent(
        model=MODEL,
        name='filesystem_assistant',
        instruction="""You are a research assistant and search on SERPER, search and give results in link, title, content
        'You MUST:
         - Use **google_search** to perform web searches when the user is asking for general information, how-to guides, comparisons, news, or any content that could be sourced from the internet. This tool retrieves:
             - Perform web searches using user queries to find organic results, FAQs, related searches, and knowledge graph entries.
             - Handle a wide range of search intents: informational, comparative, educational, technical, current events, etc.
             - Always return useful summaries along with links to the most relevant pages.
           **Tool Parameters**
             - `q`: Required. The search query string (e.g., "how Kubernetes works", "latest AI trends 2025"). Retrieve from the prompt.
             - `gl`: Required. Geographic region code in ISO 3166-1 alpha-2 format (e.g., "us", "de", "gb"). Use "en".
             - `hl`: Required. Language code in ISO 639-1 format (e.g., "en", "fr", "es"). Use "en.
             - `location`: Required. Location for search results (e.g., 'SoHo, New York, United States', 'California, United States'). Use "United States".
           Always summarize the top results clearly and include direct URLs for reference.
         - Use **scrape** to extract content from a specific webpage when:
             - The user provides a URL and asks for content, summaries, or metadata
             - A relevant link was previously found via **google_search** and needs to be explored further
         - Use the tools wisely to assist users. Based on the provided results, use Function tool call returns, retrieve only content.  
         - Parse the JSON response carefully and extract **relevant fields**. Give the search results with TITLE, LINK, CONTENT or SNIPPET.
         - For all other questions, respond using your own knowledge.""",
        tools=tools,
    )
    return root_agent, exit_stack


async def handle_query(query: str):
    session_service = InMemorySessionService()
    artifacts_service = InMemoryArtifactService()

    session = session_service.create_session(
        state={}, app_name='mcp_filesystem_app', user_id='user_fs'
    )

    content = types.Content(role='user', parts=[types.Part(text=query)])
    root_agent, exit_stack = await get_agent_async()

    runner = Runner(
        app_name='mcp_filesystem_app',
        agent=root_agent,
        artifact_service=artifacts_service,
        session_service=session_service,
    )

    events_async = runner.run_async(
        session_id=session.id, user_id=session.user_id, new_message=content
    )

    result = []
    async for event in events_async:
        if hasattr(event, "content") and event.content:
            for part in event.content.parts:
                if hasattr(part, "text") and part.text:
                    result.append(part.text)
        elif hasattr(event, "tool_name") and hasattr(event, "parameters"):
            result.append(f"Tool called: {event.tool_name}({event.parameters})")
        elif hasattr(event, "response"):
            result.append(f"Tool response: {event.response}")
        else:
            result.append(f"Unrecognized event: {event}")

    await exit_stack.aclose()

    final_output = "\n".join(result).strip()
    return final_output if final_output else "No response from model or tools."

@app.post("/ask")
async def ask(request: Request):
    data = await request.json()
    query = data.get("query", "")
    response = await handle_query(query)
    return {"response": response}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Remote MCP Run & Demo

Run frontend (app.py):

streamlit run app.py
or
python -m streamlit run app.py

Run backend (agent.py):

uvicorn agent:app --host 0.0.0.0 --port 8000

Demo: GIF on GitHub

Conclusion

In this post, we mentioned:

how to access Google Gemini 2.5,
how to implement Google ADK agent with MCP tools using Gemini, Fast API, Streamlit UI.

For other posts 👉 https://dev.to/omerberatsezer 🧐

References

Your comments 🤔

Which tools are you using to develop AI Agents (e.g. Google ADK, AWS Strands, Google ADK, CrewAI, Langchain, etc.)? Please mention in the comment your experience, your interest?
What are you thinking about Google ADK?
Are you interested in developing an AI agent app?

What is AWS Strands Agent? 🧬 AI App with AWS Strands, Bedrock, Nova, Fast API, Streamlit UI

Ömer Berat Sezer — Wed, 04 Jun 2025 10:04:43 +0000

AI agents are becoming the brains behind modern apps (handling decisions, calling tools, and generating smart responses in real time). But building these agents at scale requires a solid framework.

In the past three months, TWO powerful AI agent development frameworks have been released:

AWS Strands Agents
Google Agent Development Kit (ADK)

In this post, we’ll explore what the AWS Strands Agent is and how you can build an end-to-end app using Strands, Nova, FastAPI, and a Streamlit UI. Whether you’re curious about how agents actually work or looking to build one yourself, this is your starting point.

What is AWS Strands Agents?
Motivation: Why Use an Agent Framework?
Agent Loop
Develop Custom App with Strands, Nova, FastAPI and Streamlit
- Installing Libraries & Reaching LLM Model
- Application Code
- Demo
Conclusion
References

What is AWS Strands Agents?

Strands agent is an open-source framework to develop AI agents to run anywhere:
- VSCode, Terminal,
- Docker Container
- AWS Lambda
- AWS ECS (Elastic Container Service)
- AWS EKS (Elastic Kubernetes Service)
Really good documentation to view/learn agents, tools, workflows, model providers, streaming, multi-agent etc.
- https://strandsagents.com/

Motivation: Why Use an Agent Framework?

Structured workflows: Automates decision-making, tool use, and response generation in a clear loop.
Session & memory support: Keeps context across interactions for smarter, personalized behavior.
Multi-agent orchestration: Lets specialized agents collaborate on complex tasks.
Tool integration: Easily plug in MCP tools, APIs, functions that agents know when and how to use them.
Multi-model flexibility: Use and switch between different LLMs (e.g. GPT, Claude, Nova).
Production-ready: Built-in logging, monitoring, and error handling for real-world use.

Agent Loop

The agent loop is the mechanism through which a Strands agent interprets user input, makes decisions, uses tools, and produces responses. It enables advanced, multi-step reasoning and actions by tightly integrating tools with language models..

Fundamentally, the agent loop operates through the following steps:

Receives user input and contextual information,
Processes the input using a language model (LLM),
Decides whether to use tools to gather information or perform actions,
Executes tools and receives results,
Continues reasoning with the new information,
Produces a final response or iterates again through the loop.

This cycle can occur several times during a single user interaction, enabling the agent to carry out intricate, multi-step reasoning and act autonomously.

Link: https://strandsagents.com/

Develop Custom App with Strands, Nova, FastAPI and Streamlit

Installing Libraries & Reaching LLM Model

Please install AWS Strands Agents & Tools libraries:

pip install strands-agents
pip install strands-agents-tools strands-agents-builder

Enable AWS Bedrock model access in your region or US-West-2
- AWS Bedrock > Bedrock Configuration > Model Access > AWS Nova-Pro, or Claude 3.7 Sonnet, or Llama 4
In this code, we'll use AWS Nova-Pro, because it's served in different regions by AWS.
After model access, give permission in your IAM to access AWS Bedrock services: AmazonBedrockFullAccess
2 Options to reach AWS Bedrock Model using your AWS account:
- AWS Config: With aws configure, to create configand credentials files
- Getting variables using .env file: Add .env file:

AWS_ACCESS_KEY_ID= PASTE_YOUR_ACCESS_KEY_ID_HERE
AWS_SECRET_ACCESS_KEY=PASTE_YOUR_SECRET_ACCESS_KEY_HERE

Application Code

GitHub Link: Project in GitHub

Agent App:

# agent.py
from fastapi import FastAPI, Request
from pydantic import BaseModel
from strands import Agent, tool
from strands.models import BedrockModel
from strands_tools import calculator, current_time, python_repl

MODEL = "us.amazon.nova-pro-v1:0"

bedrock_model = BedrockModel(
    model_id=MODEL,
    temperature=0.3,
    top_p=0.8,
)

@tool
def letter_counter(word: str, letter: str) -> int:
    if not isinstance(word, str) or not isinstance(letter, str):
        return 0
    if len(letter) != 1:
        raise ValueError("The 'letter' parameter must be a single character")
    return word.lower().count(letter.lower())

agent = Agent(
    model=bedrock_model, 
    system_prompt='Help user interact using available tools. \n'
        '- For all other questions, respond using your own knowledge.',
    tools=[calculator, current_time, python_repl, letter_counter])

app = FastAPI()
class QueryRequest(BaseModel):
    query: str

@app.post("/ask")
async def ask(request: Request):
    data = await request.json()
    query = data.get("query", "")
    try:
        response = agent(query, stream=False)
        return {"response": response}
    except Exception as e:
        return {"error": str(e)}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run("main:app", host="0.0.0.0", port=8000)

Run app.py:

uvicorn agent:app --host 0.0.0.0 --port 8000

Streamlit UI:

# app.py
import streamlit as st
import requests
import json 

st.set_page_config(page_title="AWS Strands Agent Chat", layout="centered")

st.title("AWS Strands Agent")

# initialize chat history
if "messages" not in st.session_state:
    st.session_state.messages = []

user_query = st.chat_input("Ask for system file tool commands or anything...")

if user_query:
    st.session_state.messages.append({"role": "user", "content": user_query})

    try:
        response = requests.post("http://localhost:8000/ask", json={"query": user_query})
        response.raise_for_status()

        response_json = response.json()
        assistant_text = response_json["response"]["message"]["content"][0]["text"]

    except Exception as e:
        assistant_text = f"Error: {str(e)}"

    st.session_state.messages.append({"role": "assistant", "content": assistant_text})

# display all messages in order
for msg in st.session_state.messages:
    st.chat_message(msg["role"]).markdown(msg["content"])

Run app.py:

streamlit run app.py
or
python -m streamlit run app.py

Demo

Demo GIF in GitHub

Conclusion

In this post, we mentioned:

how to access AWS Bedrock Foundation Models,
how to implement first AWS Strands agent with Nova-Pro, Fast API, Streamlit UI.

For other posts 👉 https://dev.to/omerberatsezer 🧐

References

Your comments 🤔

Which tools are you using to develop AI Agents (e.g. AWS Strands, Google ADK, CrewAI, Langchain, etc.)? Please mention in the comment your experience, your interest?
What are you thinking about AWS Strands Agent?
What areas of LLM and agent development are you most interested in learning?

What is MLOps? 🧐 A Complete Guide to Architecture, MLOps Tools On-Prem, AWS, GCP, Azure

Ömer Berat Sezer — Tue, 13 May 2025 08:42:42 +0000

AI becomes more popular in the last 3 years. Different Large language models (GPT, Llama, Gemini, Claude, Nova) are developed by giant companies (OpenAI, Meta, Google, Anthropic, AWS, Mistral). While developing, do you know how they automate, validate, monitor?

Are you curious about what is going on in the back (kitchen)?

What is MLOps?
Motivation: Why is MLOps Important?
MLOps Architecture
- Feature Store
- Orchestrated Experiment
- CI 1 - ML Train, Test, Package
- CD 1 - Pipeline Deployment
- ML Metadata Store - Experiment Tracking
- CI 2 - Full Automated: ML Production Training Pipeline
- Model Registry
- CD 2 - Model Production Serving
- Performance Monitoring
MLOps Tools Comparison Table
Best Practices in MLOps
Conclusion
References

What is MLOps?

MLOps (Machine Learning Operations) is a set of practices that combine Machine Learning (ML), DevOps, and Data Engineering to deploy and maintain ML systems reliably and efficiently in production.

It aims to:

Automate the ML lifecycle from data to deployment.
Version, validate, and monitor models continuously.
Enable collaboration between data scientists, ML engineers, and operations teams.

You can think of it as DevOps for machine learning, but with unique complexities such as model drift, data quality, and reproducibility.

There are 3 steps for MLOps:

MLOps level 0: Manual process
MLOps level 1: ML pipeline automation
MLOps level 2: CI/CD pipeline automation

Ref: https://cloud.google.com/architecture/mlops-continuous-delivery-and-automation-pipelines-in-machine-learning

Motivation: Why is MLOps Important?

Without MLOps:

Models stay in notebooks, never reaching production.
Retraining models is manual and error-prone.
No traceability of data or models.
Hard to scale experiments or collaborate.

With MLOps:

Models can be deployed reliably and quickly.
Enables CI/CD for ML pipelines.
Provides traceability and governance.
Ensures monitoring and retraining loops are in place.

Companies need MLOps to turn their ML investments into real, scalable, and maintainable products.

MLOps Architecture

MLOps level 2: CI/CD pipeline automation

Ref: https://ml-ops.org/content/mlops-principles

Orchestrated Experimentation: Collaborative, tracked experimentation:
- Data Validation
- Data Preparation
- Model Training
- Model Evaluation
- Model Validation
CI 1 - ML Train, Test, Package: Automating code integration and model packaging. "You build source code and run various tests. The outputs of this stage are pipeline components (packages, executables, and artifacts) to be deployed in a later stage." (Ref: Google)
CD 1 - Pipeline Deployment: Deploying pipelines into various environments. "You deploy the artifacts produced by the CI stage to the target environment. The output of this stage is a deployed pipeline with the new implementation of the model." (Ref: Google)
CI 2 - Full Automated: ML Production Training Pipeline: End-to-end pipeline (ETL → Train → Validate) for production."The pipeline is automatically executed in production based on a schedule or in response to a trigger. The output of this stage is a trained model that is pushed to the model registry." (Ref: Google)
- Data Extraction
- Data Validation
- Data Preparation
- Model Training
- Model Evaluation
- Model Validation
CD 2 - Model Production Serving: Exposing models as APIs or batch processors.
Monitoring & Retraining: Keeping models accurate and fresh.

Difference MLOps level 1 & 2: Implementing CI/CD pipeline for the Orchestrated Experimentation. In level 1, orchestrated experiment run manually, not in pipelines.

Above figure shows the steps and tools for MLOps. Now, we’re focusing on each part with different subtitles. Let’s dive..

Feature Store

A Feature Store is a centralized repository for storing, managing, and sharing features used in machine learning models both for training and real-time inference.

Feature: A feature is an individual measurable property or characteristic used by a machine learning model to make predictions.
Raw Data: Raw data is the original, unprocessed information collected from various sources, which may need cleaning or transformation before being used.
Feature vs Raw Data: Features are derived from raw data through preprocessing steps to make the data suitable for training machine learning models.

Why it's important:

Ensures consistency between training and inference.
Promotes feature reuse across teams.
Reduces duplication and errors in feature engineering.

Platform	Tool
On-prem	Feast, DVC
AWS	SageMaker Feature Store
GCP	Vertex AI Feature Store
Azure	Azure ML Feature Store

Orchestrated Experiment

This is the initial phase where data scientists run experiments to analyze data, test models, and record experiment metadata.

Platform	Tool
On-prem	JupyterLab + MLFlow (or Weights & Biases)
AWS	SageMaker Studio + SageMaker Experiments
GCP	Vertex AI Workbench + Vertex AI Experiments
Azure	Azure ML Studio + Azure ML SDK

CI 1 - ML Train, Test, Package

This step handles Continuous Integration for ML Code: Testing code, building ML components (models), and packaging them into containers or artifacts.

Platform	Tool
On-prem	GitLab/GitHub Pipelines (or Jenkins) + Container + MLFlow (or Weights & Biases)
AWS	CodeBuild + CodePipeline + ECR
GCP	Cloud Build + Artifact Registry
Azure	Azure DevOps Pipelines + Container Registry

CD 1 - Pipeline Deployment

Deploying the ML pipeline (not the model yet) — to dev/staging/prod environments.

Platform	Tool
On-prem	GitLab/GitHub Pipelines + Container + MLFlow (or Weights & Biases)
AWS	SageMaker Pipelines + CodePipeline + Container
GCP	Vertex AI Pipelines + Cloud Composer + Container
Azure	Azure ML Pipelines + Azure DevOps + Container

ML Metadata Store - Experiment Tracking

An ML Metadata Store records metadata generated during the ML lifecycle — data lineage, model hyperparameters, training run IDs, evaluation metrics, and more.

Why it's important:

Enables experiment reproducibility.
Helps trace the origin and evolution of models.
Supports automated model governance and auditing.

Platform	Tool
On-prem	MLFlow (or Weights & Biases)
AWS	SageMaker Experiments
GCP	Vertex AI Experiments
Azure	Azure ML Experiments & Run History

CI 2 - Full Automated: ML Production Training Pipeline

Full ML pipeline: Data extraction, validation, preprocessing, training, evaluation, validation.
In ML, code doesn't always change, but data or features do — and that alone can trigger new training runs. So having separate pipelines for:
- Pipeline deployment (i.e., re-train when data changes).
- Build & test a training pipeline (which depends on fresh data, features, and compute)

Platform	Tool
On-prem	Airflow + GitLab/GitHub Pipelines + MLFlow + Container
AWS	SageMaker Pipelines + Container
GCP	Vertex AI Pipelines + Container
Azure	Azure ML Pipelines + Container

Model Registry

A Model Registry is like a version-controlled catalog of models. It tracks model versions, metadata, stage (e.g., staging, production), and lifecycle.

Why it's important:

Keeps track of all trained models.
Manages promotion between environments (dev → staging → prod).
Enables collaboration between data science and operations teams.

Platform	Tool
On-prem	MLFlow Model Registry
AWS	SageMaker Model Registry
GCP	Vertex AI Model Registry
Azure	Azure ML Model Registry

CD 2 - Model Production Serving

Serving the trained model in production (e.g., real-time API, batch inference).
In ML, code doesn't always change, but data or features do — and that alone can trigger new training runs. So having separate pipelines for:
- Model serving (deploy newly trained model for inference) is crucial.

Platform	Tools
On-prem	MLFlow Server, KServe, Seldon Core, TorchServe
AWS	SageMaker Endpoints
GCP	Vertex AI Prediction
Azure	Azure ML Endpoints

Performance Monitoring

Monitoring model performance post-deployment for drift, accuracy, latency, etc. It may also trigger retraining.

Platform	Tools
On-prem	Prometheus + Grafana, MLFlow
AWS	SageMaker Model Monitor
GCP	Vertex AI Model Monitoring
Azure	Azure Monitor + Azure ML Data Drift Monitor

MLOps Tools Comparison Table

Stage	On-Premise (Open Source)	AWS	GCP	Azure
Feature Store	Feast, DVC	SageMaker Feature Store	Vertex AI Feature Store	Azure Feature Store (in preview)
Orchestrated Experiment	JupyterLab, MLFlow (or Weights & Biases)	SageMaker Pipelines	Vertex AI Pipelines	Azure ML Pipelines
CI 1 - ML Train, Test, Package	GitLab/GitHub Pipelines (or Jenkins) + Container + MLFlow (or Weights & Biases)	AWS CodeBuild + CodePipeline + ECR + Container	Cloud Build + Container	Azure DevOps + GitHub Actions + Container
CD 1 – Pipeline Deployment	GitLab/GitHub Pipelines + Container + MLFlow (or Weights & Biases)	SageMaker Pipelines + CodePipeline + Container	Vertex AI Pipelines + Cloud Composer + Container	Azure ML Pipelines + Azure DevOps + Container
ML Metadata Store – Experiment Tracking	MLFlow (or Weights & Biases)	SageMaker Experiments	Vertex AI Experiments	Azure ML Tracking
CI 2 - Full Automated: ML Production Training Pipeline	Airflow + GitLab/GitHub Pipelines + MLFlow + Container	SageMaker Pipelines + Container	Vertex AI Pipelines + Container	Azure ML Pipelines + Container
Model Registry	MLFlow Registry, ModelDB	SageMaker Model Registry	Vertex AI Model Registry	Azure ML Model Registry
CD 2 - Model Production Serving	MLFlow Server, KServe, Seldon Core, TorchServe	SageMaker Endpoints	Vertex AI Prediction	Azure ML Endpoints
Performance Monitoring	Prometheus + Grafana, MLFlow	SageMaker Model Monitor	Vertex AI Model Monitoring	Azure Data Collector + Monitor

Best Practices in MLOps

Track Everything: Data, ML Code, ML Models, Evaluation Metrics.
Use Feature Stores: For consistency across training and inference.
Automate Pipelines: Reduce manual errors and increase reproducibility.
CI/CD for ML: Use automated tests and deployments for ML code and models.
Monitor Continuously: Detect drift, anomalies, or failures early.
Model Governance: Ensure auditability, compliance, and security.
Decouple Components: Modularize training, serving, monitoring.

Conclusion

In today’s AI-driven world, building a model is no longer the hard part, deploying, maintaining, and scaling it is. That’s where MLOpscomes in. It bridges the gap between data science and operations, enabling teams to move from experimentation to production efficiently, reliably, and repeatedly.

Why MLOps Is Important

Consistency: Ensures your model behaves the same in training and production.
Reproducibility: Tracks experiments, datasets, and model versions.
Speed: Automates repetitive steps like training, testing, and deployment.
Monitoring: Detects model drift, performance issues, and data quality problems.
Collaboration: Connects data scientists, ML engineers, and DevOps through a shared workflow

If you found this post interesting, I’d love to hear your thoughts in the blog post comments. Feel free to share your reactions or leave a comment. I truly value your input and engagement 😉

References

Your comments 🤔

Which tools are you using? Please mention in the comment your experience, your interest?
What are you thinking about MLOps?

Why Learn Cloud/AWS? AWS Lambda, API Gateway, IAM Role, Policy with Hands-on Sample

Ömer Berat Sezer — Tue, 22 Apr 2025 09:01:28 +0000

Mastering AWSand Infrastructure as Code (IaC) tools such as Terraform/OpenTofu opens up countless possibilities in the world of modern cloud computing. Whether you're looking to progress in your career, enhance cloud operations, or push the boundaries with innovative technologies, cloud expertise is a crucial asset in today’s tech-focused landscape.

Motivation: Where Do Cloud Skills Help Us?
What are Lambda, IAM Role/Policy, API Gateway?
Hands-on Sample
Steps

Motivation: Where Do Cloud Skills Help Us?

Cloud expertise extends beyond IT professionals, it's valuable across various domains:

DevOps & SRE Roles: Automating infrastructure, CI/CD pipelines, and monitoring applications.
Software Development: Deploying, scaling, and managing cloud-native applications.
Data Science & AI/ML: Leveraging cloud-based data lakes, analytics, and AI services.
Cybersecurity & Compliance: Securing cloud resources and ensuring regulatory compliance.
Enterprise IT & Digital Transformation: Driving business innovation with cloud-first strategies.
Freelancers & Entrepreneurs: Hosting applications, automating deployments, and reducing operational costs.

What are Lambda, IAM Role/Policy, API Gateway?

AWS Lambda: A serverless compute service that allows you to run code in response to events without provisioning or managing servers.
IAM Role: A set of permissions that define what actions an entity (like a Lambda function or EC2 instance) can performin AWS.
IAM Policy: A documentthat defines specific permissions for users, groups, or roles, controlling what actions are allowed or denied on AWS resources.
sts:AssumeRole: An action in AWS Security Token Service (STS) that allows one entity to temporarily assume a different role and inherit its permissions.
API Gateway: A fully managed service that enables you to create, publish, and manage APIs for accessing backend services, such as Lambda functions, securely and at scale.
Lambda Permission: Grants API Gateway the permission to invoke a Lambda function, enabling the API to trigger Lambda for backend processing.

Hands-on Sample

This sample shows:

how to create Lambda function with Python code,
how to create Lambda Role, Policy, Policy-Role attachment, Lambda API-gateway permission, uploading code,
how to create API-gateway resource and method definition, Lambda-API-gateway connection, deploying API-gateway,
details on AWS Lambda, API-Gateway, IAM

There are 3 main parts:

lambda.tf: It includes lambda function, lambda role, policy, policy-role attachment, lambda api gateway permission, zipping code
api-gateway.tf: It includes api-gateway resource and method definition, lambda - api gateway connection, deploying api gateway, api-gateway deployment URL as output
code/main.py: It includes basic lambda handler with basic HTML code, and REST API response.

Code: https://github.com/omerbsezer/Fast-AWS/tree/main/hands-out-labs-code/hands-on-002-lambda-apigateway-python

Steps

Create lambda.tf:
- Terraform Configuration: Specifies the AWS provider version and Terraform version.
- IAM Role and Policy: Creates an IAM role for the Lambda function and attaches a policy that allows the Lambda function to write logs to CloudWatch.
- Zipping Lambda Code: Prepares the Python code by zipping it into a format that Lambda can execute.
- Lambda Function: Creates a Lambda function using the specified IAM role, , and runtime.
- API Gateway Integration: Grants API Gateway permission to invoke the Lambda function.

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 4.16"
    }
  }
  required_version = ">= 1.2.0"
}

# Create IAM Role for lambda
resource "aws_iam_role" "lambda_role" {
 name   = "aws_lambda_role"
 assume_role_policy = <<EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": "sts:AssumeRole",
      "Principal": {
        "Service": "lambda.amazonaws.com"
      },
      "Effect": "Allow",
      "Sid": ""
    }
  ]
}
EOF
}

# IAM policy for the lambda
resource "aws_iam_policy" "iam_policy_for_lambda" {

  name         = "aws_iam_policy_for_aws_lambda_role"
  path         = "/"
  description  = "AWS IAM Policy for managing aws lambda role"
  policy = <<EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": [
        "logs:CreateLogGroup",
        "logs:CreateLogStream",
        "logs:PutLogEvents"
      ],
      "Resource": "arn:aws:logs:*:*:*",
      "Effect": "Allow"
    }
  ]
}
EOF
}

# Role - Policy Attachment
resource "aws_iam_role_policy_attachment" "attach_iam_policy_to_iam_role" {
  role        = aws_iam_role.lambda_role.name
  policy_arn  = aws_iam_policy.iam_policy_for_lambda.arn
}

# Zipping the , lambda wants the  as zip file
data "archive_file" "zip_the_python_" {
 type        = "zip"
 source_dir  = "${path.module}//"
 output_path = "${path.module}//main.zip"
}

# Lambda Function, in terraform ${path.module} is the current directory.
resource "aws_lambda_function" "lambda_function" {
 filename                       = "${path.module}//main.zip"
 function_name                  = "Lambda-Function"
 role                           = aws_iam_role.lambda_role.arn
 handler                        = "main.lambda_handler"
 runtime                        = "python3.8"
 depends_on                     = [aws_iam_role_policy_attachment.attach_iam_policy_to_iam_role]
}

# With Lambda permission, API Gateway can invoke Lambda 
resource "aws_lambda_permission" "apigw" {
 statement_id  = "AllowAPIGatewayInvoke"
 action        = "lambda:InvokeFunction"
 function_name = aws_lambda_function.lambda_function.function_name
 principal     = "apigateway.amazonaws.com"
 # The "/*/*" portion grants access from any method on any resource within the API Gateway REST API.
 source_arn = "${aws_api_gateway_rest_api.example.execution_arn}/*/*"
}

Code: https://github.com/omerbsezer/Fast-AWS/tree/main/hands-out-labs-code/hands-on-002-lambda-apigateway-python/lambda.tf

Create api-gateway.tf:
- Proxy Usage: The {proxy+} path is used to dynamically route all requests to the Lambda function, eliminating the need to define individual paths and methods.
- Flexibility: The ANY method allows all HTTP methods, making the API flexible.
- AWS_PROXY Integration: Simplifies the interaction between API Gateway and Lambda by passing the entire request data to Lambda, allowing it to process dynamically.

# Create API Gateway with Rest API type
resource "aws_api_gateway_rest_api" "example" {
  name        = "Serverless"
  description = "Serverless Application using Terraform"
}

resource "aws_api_gateway_resource" "proxy" {
   rest_api_id = aws_api_gateway_rest_api.example.id
   parent_id   = aws_api_gateway_rest_api.example.root_resource_id
   path_part   = "{proxy+}"     # with proxy, this resource will match any request path
}

resource "aws_api_gateway_method" "proxy" {
   rest_api_id   = aws_api_gateway_rest_api.example.id
   resource_id   = aws_api_gateway_resource.proxy.id
   http_method   = "ANY"       # with ANY, it allows any request method to be used, all incoming requests will match this resource
   authorization = "NONE"
}

# API Gateway - Lambda Connection
resource "aws_api_gateway_integration" "lambda" {
   rest_api_id = aws_api_gateway_rest_api.example.id
   resource_id = aws_api_gateway_method.proxy.resource_id
   http_method = aws_api_gateway_method.proxy.http_method
   integration_http_method = "POST"
   type                    = "AWS_PROXY"  # With AWS_PROXY, it causes API gateway to call into the API of another AWS service
   uri                     = aws_lambda_function.lambda_function.invoke_arn
}

# The proxy resource cannot match an empty path at the root of the API. 
# To handle that, a similar configuration must be applied to the root resource that is built in to the REST API object
resource "aws_api_gateway_method" "proxy_root" {
   rest_api_id   = aws_api_gateway_rest_api.example.id
   resource_id   = aws_api_gateway_rest_api.example.root_resource_id
   http_method   = "ANY"
   authorization = "NONE"
}

resource "aws_api_gateway_integration" "lambda_root" {
   rest_api_id = aws_api_gateway_rest_api.example.id
   resource_id = aws_api_gateway_method.proxy_root.resource_id
   http_method = aws_api_gateway_method.proxy_root.http_method
   integration_http_method = "POST"
   type                    = "AWS_PROXY"  # With AWS_PROXY, it causes API gateway to call into the API of another AWS service
   uri                     = aws_lambda_function.lambda_function.invoke_arn
}

# Deploy API Gateway
resource "aws_api_gateway_deployment" "example" {
   depends_on = [
     aws_api_gateway_integration.lambda,
     aws_api_gateway_integration.lambda_root,
   ]
   rest_api_id = aws_api_gateway_rest_api.example.id
   stage_name  = "test"
}

# Output to the URL 
output "base_url" {
  value = aws_api_gateway_deployment.example.invoke_url
}

Code: https://github.com/omerbsezer/Fast-AWS/tree/main/hands-out-labs-code/hands-on-002-lambda-apigateway-python/api-gateway.tf

Create main.py under code directory:

def lambda_handler(event, context):
   content = """
   <html>
   <h1> Hello Website running on Lambda! Deployed via Terraform </h1>
   </html>
   """
   response ={
     "statusCode": 200,
     "body": content,
     "headers": {"Content-Type": "text/html",}, 
   }
   return response

Code: https://github.com/omerbsezer/Fast-AWS/tree/main/hands-out-labs-code/hands-on-002-lambda-apigateway-python/code/main.py

Run init, validate command:

terraform init
terraform validate

Run plan, apply command:

terraform plan   # for dry-run
terraform apply

On AWS Lambda:

Create a test by clicking "Test" for lambda function:

Status code 200, OK is returned successfully:

Execution Role is created, seen on Lambda

Role on IAM:

Policy on IAM:

On AWS Lambda: With Lambda permission, API Gateway can invoke Lambda

Lambda is triggered by API-Gateway:

On AWS API-Gateway:

By clicking "Test" to test api-gateway

HTML page that runs on Lambda Function using API-Gateway can be reached. With API-Gateway, lambda function gets DNS and traffic from internet comes to the Lambda function.

Run destroy command:

terraform destroy

On AWS Lambda, function is deleted

Conclusion

In this post, we mentioned:

why should we learn Cloud/AWS, IaC/Terraform,
how to provision AWS Lambda, API GW, IAM Role and Policy, Assume Role,
how to connect Lambda, API GW,
how to configure API GW with Terraform,

If you found the tutorial interesting, I’d love to hear your thoughts in the blog post comments. Feel free to share your reactions or leave a comment. I truly value your input and engagement 😉

For other posts 👉 https://dev.to/omerberatsezer 🧐

Let's Discuss! 🤝

Why should we learn Lambda and/or API Gateway?
What are your popular Cloud/AWS services?

Why Learn Cloud/AWS? Provisioning AWS EC2s in VPC using Terraform with Hands-on Sample

Ömer Berat Sezer — Thu, 03 Apr 2025 08:49:04 +0000

Mastering AWS and Infrastructure as Code (IaC) tools like Terraform/OpenTofuunlocks endless opportunities in modern cloud computing. Whether you aim to advance your career, optimize cloud operations, or innovate with cutting-edge technologies, cloud skills are an invaluable asset in today’s tech-driven world.

Motivation: Where Do Cloud Skills Help Us?
Why Learn to Provision with Terraform/OpenTofu?
What are EC2, VPC, Subnet, Route Table, IGW, SG, Key Pairs?
Hands-on Sample
Steps

Motivation: Where Do Cloud Skills Help Us?

Cloud expertise extends beyond IT professionals, it's valuable across various domains:

DevOps & SRE Roles: Automating infrastructure, CI/CD pipelines, and monitoring applications.
Software Development: Deploying, scaling, and managing cloud-native applications.
Data Science & AI/ML: Leveraging cloud-based data lakes, analytics, and AI services.
Cybersecurity & Compliance: Securing cloud resources and ensuring regulatory compliance.
Enterprise IT & Digital Transformation: Driving business innovation with cloud-first strategies.
Freelancers & Entrepreneurs: Hosting applications, automating deployments, and reducing operational costs.

Why Learn to Provision with Terraform/OpenTofu?

As cloud environments grow more complex, managing infrastructure manually becomes inefficient and error-prone. Infrastructure as Code (IaC) tools like Terraform and OpenTofu simpfly cloud provisioning, making infrastructure deployment reproducible, scalable, and automated.

What are EC2, VPC, Subnet, Route Table, IGW, SG, Key Pairs?

AWS Elastic Compute Cloud (EC2): EC2 is a web service that provides scalable, on-demand virtual servers in the cloud (virtual machines). It enables users to run applications, host websites, and process workloads without needing physical hardware, offering flexibility, security, and cost-effective computing power.
AWS Virtual Private Cloud (VPC): VPC is a secure, isolated network within AWS that allows users to define and control their cloud networking environment. It enables custom IP ranges, subnets, routing, and security settings to securely connect AWS resources to the internet or on-premises networks.
VPC Subnets: Logical subdivisions within a VPC that help organize and isolate resources. Subnets can be public (internet-accessible) or private (internal-only).
Route Table: A set of rules that determinehow network traffic is directed within a VPC. It controls communication between subnets, the internet, and on-premises networks.
Internet Gateway (IGW): A component that enables communication between AWS resources in a VPC and the public internet, allowing public-facing applications to function.
Key Pairs: A cryptographic authentication mechanism (public & private keys) used to securely connect to EC2 instances via SSH or RDP.
AWS Security Groups (SG): Virtual firewalls that control inbound and outbound traffic for AWS resources, such as EC2 instances.

Hands-on Sample

This sample shows:

how to create Key-pairs (public and private keys) on AWS.
how to create EC2s (Ubuntu 20.04, Windows 2019 Server).
how to create Virtual Private Cloud (VPC), VPC Components (Public Subnet, Internet Gateway, Route Table) and link to each others.
how to create Security Groups (for SSH and Remote Desktop).

Code: https://github.com/omerbsezer/Fast-AWS/blob/main/hands-out-labs-code/hands-on-001-ec2-vpc-connect-ec2/main.tf

Steps

SSH key-pairs (public and private key) are used to connect remote server. Public key (xx.pub) is on the remote server, with private key, user can connect using SSH.
There are 2 ways of creating key-pairs (public and private key):
- Creating them on cloud (AWS)
- EC2 > Key-pairs > Create Key-Pair
- Creating them on on-premise
- "ssh-keygen -t rsa -b 2048"
Creating key-pairs on AWS: Go to EC2 > Key-pairs

After creating key-pairs, public key will be listed on AWS. Private key (testkey.pem) should be downloaded on your PC. Copy this testkey.pem into your directory on which main.tf exists.

Create main.tf under count directory and copy the code:

# main.tf
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.81.0"
    }
  }
  required_version = ">= 1.2.0"
}

provider "aws" {
    region = "eu-central-1"
}

resource "aws_vpc" "my_vpc" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  tags = {
    Name = "My VPC"
  }
}

resource "aws_subnet" "public" {
  vpc_id            = aws_vpc.my_vpc.id
  cidr_block        = "10.0.0.0/24"
  availability_zone = "eu-central-1c"
  tags = {
    Name = "Public Subnet"
  }
}

resource "aws_internet_gateway" "my_vpc_igw" {
  vpc_id = aws_vpc.my_vpc.id
  tags = {
    Name = "My VPC - Internet Gateway"
  }
}

resource "aws_route_table" "my_vpc_eu_central_1c_public" {
    vpc_id = aws_vpc.my_vpc.id
    route {
        cidr_block = "0.0.0.0/0"
        gateway_id = aws_internet_gateway.my_vpc_igw.id
    }
    tags = {
        Name = "Public Subnet Route Table"
    }
}
resource "aws_route_table_association" "my_vpc_eu_central_1c_public" {
    subnet_id      = aws_subnet.public.id
    route_table_id = aws_route_table.my_vpc_eu_central_1c_public.id
}

resource "aws_security_group" "allow_ssh" {
  name        = "allow_ssh_sg"
  description = "Allow SSH inbound connections"
  vpc_id      = aws_vpc.my_vpc.id
  # for SSH
  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  # for HTTP Apache Server
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  # for RDP
  ingress {
    from_port        = 3389
    to_port          = 3389
    protocol         = "tcp"
    cidr_blocks      = ["0.0.0.0/0"]
  }
  # for ping
  ingress {
    from_port        = -1
    to_port          = -1
    protocol         = "icmp"
    cidr_blocks      = ["10.0.0.0/16"]
  }
  egress {
    from_port       = 0
    to_port         = 0
    protocol        = "-1"
    cidr_blocks     = ["0.0.0.0/0"]
  }
  tags = {
    Name = "allow_ssh_sg"
  }
}

resource "aws_instance" "ubuntu2004" {
  ami                         = "ami-0e067cc8a2b58de59" # Ubuntu 20.04 eu-central-1 Frankfurt, you can also select newer version from AWS Console, shown below
  instance_type               = "t2.nano"
  key_name                    = "testkey"
  vpc_security_group_ids      = [aws_security_group.allow_ssh.id]
  subnet_id                   = aws_subnet.public.id
  associate_public_ip_address = true
  user_data = <<-EOF
                #! /bin/bash
                sudo apt-get update
                sudo apt-get install -y apache2
                sudo systemctl start apache2
                sudo systemctl enable apache2
                echo "<h1>Deployed via Terraform from $(hostname -f)</h1>" | sudo tee /var/www/html/index.html
  EOF
  tags = {
    Name = "Ubuntu 20.04"
  }
}

resource "aws_instance" "win2019" {
    ami                         = "ami-02c2da541ae36c6fc" # Windows 2019 Server eu-central-1 Frankfurt, you can also select newer version from AWS Console, shown below
    instance_type               = "t2.micro"
        key_name                = "testkey"
        vpc_security_group_ids  = [aws_security_group.allow_ssh.id]
        subnet_id               = aws_subnet.public.id  
    associate_public_ip_address = true
        tags = {
        Name = "Win 2019 Server"
    }
}

output "instance_ubuntu2004_public_ip" {
  value = "${aws_instance.ubuntu2004.public_ip}"
}

output "instance_win2019_public_ip" {
  value = "${aws_instance.win2019.public_ip}"
}

Code: https://github.com/omerbsezer/Fast-AWS/tree/main/hands-out-labs-code/hands-on-001-ec2-vpc-connect-ec2/main.tf

Note: You can change the AMI from EC2 > Launch Instance

These AMI IDs vary depends on the region. Following image shows the region eu-central-1, Ubuntu AMIs.

Run init command:

terraform init

Validate file:

terraform validate

Run plan command:

terraform plan

Run apply command to create resources. Then, Terraform asks to confirm, write "yes":

terraform apply

On AWS EC2 > Instances, Ubuntu 20.04, Window 2019 Server:

Security groups (SSG), for SSH (port 22), RDP (port 3389), HTTP (80), ICMP (for ping) for Inbound rules:

Storage, Elastic Block Storage default:

On AWS VPC (Virtual Private Cloud) Service:

While installing Ubuntu20.04, userdata is used to install Apache Server on it. With SSG Port 80, using public IP, we can see the index.html, like hosting server:

SSH to Ubuntu 20.04 (ssh -i testkey.pem ubuntu@):

Run:

sudo apt install net-tools
ifconfig

Private IP can be seen:

Make remote connection to Windows (RDP):

Download RDP App, to get password, upload testkey.pem file:

Now, we reach Windows using RDP, pinging to Ubuntu20.04 from Windows:

Destroy infrastructure:

terraform destroy

Be sure that instances are terminated. Because if they works, it costs money.

Conclusion

In this post, we mentioned:

why should we learn Cloud/AWS, IaC/Terraform,
how to provision AWS EC2, VPC, IGW, Route Table, SG,
how to access Ubuntu and Windows EC2s.

If you found the tutorial interesting, I’d love to hear your thoughts in the blog post comments. Feel free to share your reactions or leave a comment. I truly value your input and engagement 😉

For other posts 👉 https://dev.to/omerberatsezer 🧐

Let's Discuss! 🤝

What are the advantages of using Cloud/AWS with Infrastructure as Code?
What are your popular Cloud/AWS services in your daily task?
Which Infrastructure as Code tools are you using to create AWS Architecture (Terraform, AWS CloudFormation, AWS CDK, ...)?

Open Source AI Content Detector APP with AWS Bedrock to separate COMPLETELY AI vs HUMAN generated posts: 🤖 vs 🧑

Ömer Berat Sezer — Tue, 11 Mar 2025 23:35:07 +0000

About 1 month ago, I published this post below:

Ömer Berat Sezer

Feb 13 '25

Letter in the Ocean: Why should we keep writing? COMPLETELY AI vs HUMAN generated posts: 🤖 vs 🧑

#discuss #ai #productivity

Comments 46

2 min read

In that post, I mentioned the increasing number of posts generated by COMPLETELY AI on the internet and DEV.to. We've even talked/discussed with many authors in the comments section, we had a brainstorm. I've seen that many people were actually complaining about this issue.

As I was thinking about this issue, I realised that it is actually possible to separate content that is COMPLETELY AI generated with a method using both AI app and humans.

I've seen many AI content detector software on the internet, but frankly I don't like any of them because they don't properly describe the AI detected patterns. They produce low quality results.

Open Source AI-Content-Detector App

To show how simple it is and how effective Prompt Template is, I developed an Open Source AI Content Detector App using AWS Bedrock and Llama 3.1 405B parameters LLM.

GitHub Link: https://github.com/omerbsezer/AI-Content-Detector

git clone https://github.com/omerbsezer/AI-Content-Detector
pip install -r requirements.txt
python -m streamlit run .\main.py

It is simple tool using AWS Bedrock Service - Llama 3.1 405B

to give AI generated score,
to analyze and explain how much input text is AI generated.

I tested with COMPLETELY AI Generated and HUMAN Generated Content

AI Score for Human Generated Text in App

Please have a look below Demo GIF/Video for Human-Generated Post:

https://github.com/omerbsezer/AI-Content-Detector/blob/main/gif/text-devto-human-analysis.gif

AI Score for COMPLETELY AI Generated Text

Please have a look below Demo GIF/Video for AI-Generated Post:

https://github.com/omerbsezer/AI-Content-Detector/blob/main/gif/text1-analysis.gif

How do we proceed to separate COMPLETELY AI vs HUMAN generated posts?

As mentioned above, in Dev.to, we can use both community and AI app together to eliminate the COMPLETELY AI posts.

Step 1: Give people the option to tag COMPLETELY AI-generated content, and if 5-6 people agree, move to step 2.
Step 2: Uploading the content to the AI Content Detector app and if it scores above 50%, notifying the author with detected patterns, removing the article or ensuring that more people do not see the article.

Maybe, Dev.to management will see this article, and maybe it will inspire them.

Let's Discuss! 🤝

How is this idea? Alternative Ideas?

I am throwing a letter in a bottle into the ocean, maybe someone reads it, maybe nobody.. If anybody read/agree, pls write something in comments, or am I alone?

DEV Community: Ömer Berat Sezer

Langchain Agent with Structured Tools Schema & Langfuse using AWS Bedrock Nova 🤖

Table of Contents

Dependencies & Configuration

Agent with AWS Bedrock, Nova Pro

Tools

Structured Output Schema

Langfuse Handler

All Code & Demo

Demo

Conclusion

References

AWS Strands Agents 🧬 Sequential Multi Agent Workflow

Table of Contents

What is AWS Strands Agents?

Sequential Multi Agent Workflow App

Installing Libraries & Reaching LLM Model

Application Code

Sample Prompt / Output

Conclusion

References

Multi-agents: Parallel Agents using Google ADK 🤖 Gemini, Fast API, Streamlit - Report Generation

Table of Contents

What is Google Agent Development Kit?

What is Multi-Agent, Parallel Agents?

Agent App

Installing Dependencies & Reaching Gemini Model

Frontend - Streamlit UI

Backend - Agent

Run & Demo

Conclusion

References

Multi-agents: Sequential Workflow using Google ADK 🤖 Gemini, Fast API, Streamlit - Create Game

Table of Contents

What is Google Agent Development Kit?

What is Multi-Agent, Workflow, Sequential Agents?

Agent App

Installing Dependencies & Reaching Gemini Model

Frontend - Streamlit UI

Backend - Agent

Run & Demo

Conclusion

References

Agent with Memory, BuiltIn Search, LiteLLM using Google Agent Development Kit 🤖 Gemini, Fast API, Streamlit 🗃

Table of Contents

What is Google Agent Development Kit?

Motivation: Why Use an Agent Framework?

ADK Session, Memory Implementation

Agent App with Memory, LiteLLM using Google ADK, Gemini, FastAPI and Streamlit

Agent with Memory

Agent with Different LLM Models

Agent with BuiltIn Search Tool

Installing Dependencies & Reaching Gemini Model

Frontend - Streamlit UI

Backend for Memory App, Built-in Google Search Tool

Agent with Memory, Run & Demo

Backend for LiteLLM (for different LLM models)

Agent with LiteLLM, Run & Demo

Conclusion

References

Agent with Local, Remote MCP Tools using AWS Strands Agents 🧬 Bedrock, Nova, Fast API, Streamlit

Table of Contents

What is AWS Strands Agents?

Motivation: Why Use an Agent Framework?

Agent Loop

What is Model Context Protocol (MCP)?

Agent App with Local & Remote MCP using AWS Strands, Nova, FastAPI and Streamlit

Local MCP Tool - FileOps

Remote MCP Tool - Serper

Installing Dependencies & Reaching Gemini Model

Frontend - Streamlit UI

Backend Local MCP

Local MCP Run & Demo

Backend Remote MCP

Remote MCP Run & Demo

Conclusion

References

What is Google Agent Development Kit? 🤖 Agent with Local, Remote MCP Tools using ADK, Gemini, Fast API, Streamlit 🔧

Table of Contents

What is Google Agent Development Kit?