DEV Community: Yogesh Sharma

Aws devops agent

Yogesh Sharma — Sun, 07 Dec 2025 10:39:50 +0000

Ai powered clouwatch log analysis

Yogesh Sharma — Wed, 12 Nov 2025 09:07:05 +0000

Conversational Analytics with AWS Bedrock and Strands Multi‑Agent Framework

Yogesh Sharma — Wed, 12 Nov 2025 09:06:40 +0000

Business intelligence is undergoing a transformation. Instead of relying on SQL queries, Python scripts, and manual dashboards, organizations are moving toward conversational analytics — systems that understand natural language and automatically discover, analyze, and visualize enterprise data.

This blog explores how to build a Multi‑Agent Generative BI Platform using AWS Bedrock, the Strands Agents SDK, and the Model Context Protocol (MCP). We’ll also see how Standard Operating Procedures (SOPs) bring structure and reliability to agent behavior.

The Challenge: Bridging Business and Data

In most enterprises, business users depend on technical teams to answer data questions. A simple query like “What are last quarter’s top‑performing products?” can take days to resolve because it requires SQL expertise, data manipulation, and visualization skills.

This delay creates friction and inconsistency — different analysts produce different results, and insights often arrive too late to act on. The goal is to eliminate this dependency by enabling direct, natural‑language interaction with data.

The Use Case: Oil & Gas Analytics (and Beyond)

Our prototype focuses on oil & gas production analytics, where structured datasets (well logs, sensor readings, geological surveys) are abundant.
Typical questions include:
“Which wells are underperforming?”
“Show production trends for the last six months.”
“Forecast next quarter’s output.”

But the architecture is domain‑agnostic.
Swap the MCP connectors and SOPs, and it works for:
Retail → “same‑store sales,” “inventory turnover.”
Healthcare → HIPAA‑compliant data access via FHIR.
Finance → “risk‑adjusted returns,” “customer lifetime value.”

The Solution: Flattened Multi‑Agent Architecture

Traditional multi‑agent systems use deep delegation chains — agents calling sub‑agents recursively. This increases latency and token cost.
Our design uses a flattened hierarchy:

Role	Responsibility
Supervisor Agent	Routes queries, enforces SOPs
Data Steward Agent	Handles data discovery via MCP
Data Visualizer Agent	Generates charts and uploads to S3

Each agent operates independently but follows strict SOPs for predictable behavior.

Why SOPs Matter

LLMs are probabilistic — their outputs can vary. SOPs introduce determinism and auditability.
Each agent has a markdown file defining its rules using RFC 2119 keywords:

# Visualization SOP

## Constraints
- MUST use matplotlib or seaborn for chart generation
- MUST sort data before visualization
- MUST upload chart to S3 bucket: {s3_bucket}
- MUST return the S3 URI in the response

SOPs act as contracts between developers and agents — version‑controlled, reviewable, and debuggable.

Architecture Overview

Below is a hand‑drawn Excalidraw‑style sketch showing how the system components interact:

Business User asks a question.

Supervisor Agent interprets intent and delegates tasks.

Data Steward Agent queries data via MCP.

Data Visualizer Agent generates charts using Bedrock’s Code Interpreter.

AWS Bedrock executes code securely and uploads results to S3.

Implementation in Python

Here’s a simplified Python workflow using the Strands SDK and AWS Bedrock:

from strands import Agent, Supervisor
from strands.sop import load_sop
from bedrock import BedrockClient
import boto3

# Initialize AWS Bedrock client
bedrock = BedrockClient(region="us-east-1")

# Load SOPs
data_steward_sop = load_sop("sops/data_steward.md")
visualizer_sop = load_sop("sops/visualizer.md")

# Define specialized agents
class DataStewardAgent(Agent):
    def query(self, question: str):
        # Example: query via MCP (Athena or SQLite MCP server)
        return {
            "well_id": ["W1", "W2", "W3"],
            "production": [1200, 950, 870]
        }

class DataVisualizerAgent(Agent):
    def visualize(self, data, chart_type="bar"):
        code = f"""
import matplotlib.pyplot as plt
wells = {data['well_id']}
production = {data['production']}
plt.bar(wells, production)
plt.title("Top Wells by Oil Production")
plt.savefig("/tmp/chart.png")
        """
        result = bedrock.execute_code(code)
        s3 = boto3.client("s3")
        s3.upload_file("/tmp/chart.png", "my-bi-bucket", "charts/wells.png")
        return "s3://my-bi-bucket/charts/wells.png"

# Supervisor orchestrates agents
class SupervisorAgent(Supervisor):
    def handle_query(self, query: str):
        data = DataStewardAgent(sop=data_steward_sop).query(query)
        chart_uri = DataVisualizerAgent(sop=visualizer_sop).visualize(data)
        return chart_uri

# Example run
supervisor = SupervisorAgent()
result = supervisor.handle_query("Show me the top 10 wells by oil production")
print("Chart available at:", result)

AWS Bedrock + Strands Framework Synergy

AWS Bedrock provides the secure foundation for LLM execution, guardrails, and code interpretation.
The Strands Framework orchestrates multiple agents with SOP‑driven reliability.

Together, they enable:

Secure LLM Execution

Structured Agent Collaboration

Domain‑agnostic Extensibility

Conversational BI at Scale

Key Benefits

Feature	Impact
Natural‑language interface	Removes technical barriers for business users
SOP‑driven governance	Predictable, auditable agent behavior
Security by design	MCP blocks unsafe SQL; Bedrock Guardrails filter content
Extensible architecture	Add new agents by defining SOPs and delegation tools
Rapid insights	End‑to‑end query‑to‑visualization in under 60 seconds

//Update 30th Apr//

AWS announced Strands Labs, a new GitHub organization created to give developers a hands‑on space for experimenting with cutting‑edge approaches to agentic AI

Conclusion

The combination of AWS Bedrock and Strands Framework represents a new paradigm for enterprise analytics — one where business users interact directly with data through natural language, and multi‑agent systems deliver consistent, auditable results.

This architecture is a blueprint for domain‑agnostic, conversational BI that scales across industries.

Strands agent

Yogesh Sharma — Wed, 12 Nov 2025 09:06:25 +0000

Mcp

Yogesh Sharma — Tue, 30 Sep 2025 11:31:30 +0000

Bedrock core

Yogesh Sharma — Tue, 30 Sep 2025 11:31:10 +0000

Building and Deploying AWS Bedrock Agents in a Serverless Way

Yogesh Sharma — Tue, 16 Sep 2025 14:10:48 +0000

The rise of agentic AI systems has transformed how enterprises build intelligent applications. Instead of manually orchestrating workflows, AWS Bedrock Agents allow developers to define autonomous agents that can interact with models, APIs, and organizational data—without managing infrastructure. When combined with serverless AWS services, this creates a scalable, cost‑efficient, and production‑ready environment for deploying AI agents.

In this blog, we’ll explore:

What AWS Bedrock Agents are
Their architecture and capabilities
How to deploy them in a serverless way using AWS Lambda, API Gateway, and Step Functions
Best practices for observability, scaling, and security

What Are AWS Bedrock Agents?

AWS Bedrock Agents are managed AI agents that:

Coordinate tasks across models, APIs, and knowledge bases
Integrate seamlessly with Bedrock features like Knowledge Bases and Guardrails
Support configuration-driven development (no custom infrastructure required)
Provide built-in tracing for debugging and observability

They are ideal for:
Enterprises needing autonomous workflows without building agents from scratch
Teams that want rapid deployment through configuration rather than code
Applications requiring tight integration with AWS Bedrock’s ecosystem

Serverless Deployment Architecture

A serverless approach ensures that agents scale automatically, reduce operational overhead, and only incur costs when invoked. Here’s a reference architecture:

API Gateway Acts as the entry point for client requests.

Routes incoming HTTP calls to AWS Lambda functions.

Provides authentication and throttling.

AWS Lambda Hosts the agent orchestration logic.

Invokes Bedrock Agent APIs to process tasks.

Can integrate with external APIs or AWS services (e.g., DynamoDB, S3).

AWS Step Functions Manages multi-step workflows.

Useful when agents need to call multiple APIs or models in sequence.

Provides visual workflow monitoring.

Amazon Bedrock Executes the agent reasoning and orchestration.

Connects to Knowledge Bases for contextual responses.

Applies Guardrails for compliance and safety.

Observability CloudWatch Logs & Metrics for monitoring agent execution.

X-Ray tracing for debugging workflows.

Bedrock tracing tools for step-by-step reasoning visibility.

Understanding AWS Bedrock Agents

Autonomous orchestration: Agents can reason through multi-step goals, call APIs, and adapt workflows dynamically.

Integration with Bedrock features: Knowledge Bases, Guardrails, and AgentCore primitives (Memory, Identity, Observability).

Configuration-driven: Define agents via API schemas and prompts, without custom infrastructure.

Tracing & observability: Built-in reasoning cycle tracking for debugging and compliance.

Below is a detailed Lambda function that integrates with Amazon Bedrock Agents, manages session state in DynamoDB, and exposes the agent via API Gateway. This example shows how to build a production‑ready serverless deployment.

import boto3
import json
import os
import logging
from botocore.exceptions import ClientError
from datetime import datetime

# Configure logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)

# Initialize AWS clients
bedrock_client = boto3.client("bedrock-agent-runtime")
dynamodb = boto3.resource("dynamodb")
table_name = os.environ.get("SESSION_TABLE", "AgentSessions")
session_table = dynamodb.Table(table_name)

AGENT_ID = os.environ.get("AGENT_ID", "your-agent-id")

def get_session(session_id: str):
    """Retrieve session state from DynamoDB."""
    try:
        response = session_table.get_item(Key={"sessionId": session_id})
        return response.get("Item", {})
    except ClientError as e:
        logger.error(f"Error fetching session: {e}")
        return {}

def save_session(session_id: str, state: dict):
    """Persist session state to DynamoDB."""
    try:
        session_table.put_item(Item={"sessionId": session_id, "state": state})
    except ClientError as e:
        logger.error(f"Error saving session: {e}")

def lambda_handler(event, context):
    try:
        body = json.loads(event.get("body", "{}"))
        session_id = body.get("sessionId", f"session-{datetime.utcnow().isoformat()}")
        query = body.get("query", "")

        if not query:
            return {"statusCode": 400, "body": json.dumps({"error": "Missing query"})}

        # Retrieve session state
        session_state = get_session(session_id)

        # Invoke Bedrock Agent
        response = bedrock_client.invoke_agent(
            agentId=AGENT_ID,
            inputText=query,
            sessionState=session_state
        )

        # Extract agent output
        agent_output = response.get("outputText", "No response from agent")

        # Update session state
        new_state = response.get("sessionState", {})
        save_session(session_id, new_state)

        # Return response
        return {
            "statusCode": 200,
            "body": json.dumps({
                "sessionId": session_id,
                "query": query,
                "response": agent_output,
                "state": new_state
            })
        }

    except Exception as e:
        logger.error(f"Unexpected error: {e}")
        return {"statusCode": 500, "body": json.dumps({"error": str(e)})}

Deployment Steps

Create DynamoDB Table Define a table named AgentSessions.

Set Partition key: sessionId (String).

This table will store agent session state for continuity across Lambda invocations.

Deploy Lambda Function Write a Lambda function that invokes your Bedrock Agent.

Attach an IAM role with:

bedrock-agent-runtime:InvokeAgent permissions

DynamoDB read/write permissions for the session table

Configure API Gateway Create a REST or HTTP API in API Gateway.

Route POST requests to your Lambda function.

Enable Amazon Cognito authentication if you want secure user identity management.

Set Environment Variables AGENT_ID → Your Bedrock Agent ID.

SESSION_TABLE

Benefits of This Approach

Scalable: Lambda auto‑scales with demand.
Stateful Conversations: DynamoDB persists agent memory across invocations.
Secure: IAM roles enforce least privilege.
Observable: Logs and metrics in CloudWatch.

Best Practices

By embedding architectural principles into your deployment, you ensure that your agents are not only functional but also production‑ready.

Operational Excellence

Treat agents as living systems. Automate monitoring with CloudWatch, trace reasoning cycles, and log every interaction for auditability. This ensures smooth operations and quick recovery when workflows evolve.

Security

Protect agent endpoints with IAM roles, Cognito authentication, and API Gateway throttling. Sanitize inputs to prevent prompt injection and enforce compliance through Guardrails. Security must be baked into every layer of the architecture.

Reliability

Use stateless Lambda functions with externalized session state in DynamoDB or S3. This design guarantees resilience and fault tolerance, even under unpredictable workloads.

Performance Efficiency

Optimize model usage by selecting the right foundation model for each task. Bedrock’s managed runtime ensures low latency, while serverless scaling keeps performance consistent across spikes in demand.

Cost Optimization

Monitor token usage and execution time. Use Step Functions for multi‑step workflows instead of chaining Lambdas, reducing overhead. Pay‑per‑use economics make serverless AI cost‑effective when designed carefully.

Sustainability

Favor lightweight, stateless designs and efficient model invocation. Reducing unnecessary compute cycles not only saves money but also lowers environmental impact — aligning with sustainable AI practices.

// Update (Fresh from Oven) 1st May

Amazon Bedrock now offers OpenAI models, Codex, and Managed Agents Limited Preview
Amazon Bedrock AgentCore launches capabilities for optimizing agent performance in preview

Conclusion

The convergence of AWS Bedrock Agents and serverless architecture marks a pivotal shift in how AI applications are built and deployed. By leveraging Lambda, API Gateway, DynamoDB, and Amazon Bedrock, developers can orchestrate intelligent, autonomous workflows without managing infrastructure. This approach not only simplifies deployment but also ensures scalability, cost efficiency, and operational resilience.

From defining agents and integrating them with Bedrock’s AgentCore, to persisting state in DynamoDB and exposing endpoints via API Gateway, the entire pipeline embodies the principles of modern cloud-native AI engineering. It empowers teams to focus on logic and outcomes rather than servers and scaling.

As enterprises move toward agentic AI systems, AWS Bedrock provides the foundation for building secure, auditable, and production-ready AI agents that can reason, act, and evolve autonomously. The future of AI development is serverless, modular, and intelligent—and Bedrock Agents are leading that transformation.

AWS mcp server

Yogesh Sharma — Tue, 16 Sep 2025 14:10:12 +0000

AWS mcp server

AWS Strands Agent

Yogesh Sharma — Tue, 16 Sep 2025 14:09:51 +0000

AWS Strands Agent

Bedrock

Yogesh Sharma — Tue, 31 Dec 2024 20:38:28 +0000

Bedrock

Yogesh Sharma — Fri, 29 Nov 2024 01:40:09 +0000

Ai agent

Yogesh Sharma — Fri, 29 Nov 2024 01:39:18 +0000

DEV Community: Yogesh Sharma

Aws devops agent

Ai powered clouwatch log analysis

Conversational Analytics with AWS Bedrock and Strands Multi‑Agent Framework

The Challenge: Bridging Business and Data

The Use Case: Oil & Gas Analytics (and Beyond)

The Solution: Flattened Multi‑Agent Architecture

Why SOPs Matter

Architecture Overview

Implementation in Python

AWS Bedrock + Strands Framework Synergy

Key Benefits

//Update 30th Apr//

Conclusion

Strands agent

Mcp

Bedrock core

Building and Deploying AWS Bedrock Agents in a Serverless Way

What Are AWS Bedrock Agents?

Serverless Deployment Architecture

Understanding AWS Bedrock Agents

Deployment Steps

Benefits of This Approach

Best Practices

Operational Excellence

Security

Reliability

Performance Efficiency

Cost Optimization

Sustainability

// Update (Fresh from Oven) 1st May

Conclusion

AWS mcp server

AWS Strands Agent

Bedrock

Bedrock

Ai agent

Conversational Analytics with AWS Bedrock and Strands Multi‑Agent Framework

The Use Case: Oil & Gas Analytics (and Beyond)

AWS Bedrock + Strands Framework Synergy