DEV Community: Adeline Makokha [AWS Hero]

Build a Memory-Powered Multi-Agent Financial Advisor with Strands SDK & Amazon Bedrock

Adeline Makokha [AWS Hero] — Thu, 23 Apr 2026 14:36:12 +0000

Why Agents — Not Just Chatbots

A chatbot answers your question and forgets you. An AI agent takes actions, uses tools, and loops until the job is actually done. The difference isn't the model, it's the architecture.

The agent loop has four steps:

Perceive- read the user's request plus any injected context (memory, RAG results, past turns)
Plan- reason about what to do next; choose which tool(s) to call
Act- call the chosen tool(s), APIs, or sub-agents
Reflect- evaluate the results; decide whether the task is done or the loop should continue

Unlike a simple LLM call, the agent decides autonomously when it has gathered enough information to answer and it keeps going until it has.

The Project: A Multi-Agent Financial Advisor

To make this concrete, we'll build a memory-powered multi-agent financial advisor. It:

Accepts natural-language questions ("Should I rebalance my portfolio?")
Delegates to specialist sub-agents for portfolio data, market prices, and financial news
Uses Amazon Bedrock Guardrails to enforce compliance rules at every step
Stores client preferences and past conversations using Amazon Bedrock AgentCore Memory
Deploys as a serverless endpoint with a single agentcore deploy command

The full stack:

Layer	Technology
Agent framework	Strands Agents SDK (open-source)
Foundation model	Claude 3.5 Sonnet via Amazon Bedrock
Safety layer	Amazon Bedrock Guardrails
Memory layer	Amazon Bedrock AgentCore Memory
Runtime	Amazon Bedrock AgentCore Runtime
Observability	AWS CloudWatch + OpenTelemetry

The orchestrator agent receives every user request and intelligently routes sub-tasks to the right specialist. Results are synthesized into a single, coherent response.

Meet the Strands Agents SDK

Strands is an open-source Python framework from AWS Labs that makes building production agents dramatically simpler. You define tools, wrap them in an Agent, and Strands handles the loop.

pip install strands-agents

The core idea is minimal boilerplate. Three imports and a decorator are enough to expose any Python function to an agent as a callable tool.

Step 1 — Define Tools with `@tool`

The @tool decorator does the heavy lifting automatically:

Parses Python type hints into a JSON schema the model can read
Converts the docstring into the tool's description (what the agent uses to decide when to call it)
Handles invocation so the agent decides when, and with what arguments, to call the function

# tools/financial_tools.py
from strands import tool
from typing import Optional

@tool
def get_portfolio_value(
    client_id: str,
    include_unrealized_gains: bool = True
) -> dict:
    """Retrieve the current portfolio value and positions for a client."""
    return fetch_portfolio_data(client_id, include_unrealized_gains)


@tool
def get_market_data(tickers: list[str], period: str = "1d") -> dict:
    """Retrieve current market prices and key metrics for a list of tickers."""
    return fetch_market_prices(tickers, period)


@tool
def get_financial_news(query: str, max_results: int = 5) -> dict:
    """Retrieve recent financial news articles relevant to a query."""
    return fetch_news_feed(query, max_results)


@tool
def get_risk_analysis(
    client_id: str,
    risk_tolerance: Optional[str] = None
) -> dict:
    """Perform a risk analysis on a client's portfolio."""
    return compute_risk_metrics(client_id, risk_tolerance)


@tool
def get_investment_recommendations(
    client_id: str,
    goal: str = "growth",
    time_horizon_years: int = 10
) -> dict:
    """Generate personalised investment recommendations for a client."""
    return generate_recommendations(client_id, goal, time_horizon_years)

Each function becomes a first-class tool — no YAML, no schema files, no extra config.

Step 2- Build Specialist Sub-Agents

Rather than one monolithic agent with 15 tools, we split responsibilities. Each specialist agent gets only the tools it needs, which keeps the system prompt focused and improves tool selection accuracy.

# agents/specialists.py
from strands import Agent
from strands.models import BedrockModel
from tools.financial_tools import (
    get_portfolio_value, get_risk_analysis,
    get_market_data, get_financial_news,
)

MODEL_ID = "us.anthropic.claude-3-5-sonnet-20241022-v2:0"

def _make_model(guardrail_id: str | None) -> BedrockModel:
    kwargs = {"model_id": MODEL_ID, "region_name": "us-east-1"}
    if guardrail_id:
        kwargs["guardrail_id"] = guardrail_id
        kwargs["guardrail_version"] = "DRAFT"
    return BedrockModel(**kwargs)


def create_portfolio_agent(guardrail_id: str | None = None) -> Agent:
    return Agent(
        model=_make_model(guardrail_id),
        system_prompt=(
            "You are a Portfolio Specialist. Analyse holdings, risk metrics, "
            "and P&L. Be precise and cite specific numbers."
        ),
        tools=[get_portfolio_value, get_risk_analysis],
    )


def create_market_data_agent(guardrail_id: str | None = None) -> Agent:
    return Agent(
        model=_make_model(guardrail_id),
        system_prompt=(
            "You are a Market Data Specialist. Provide current prices, "
            "52-week ranges, and key indices. Stick to facts."
        ),
        tools=[get_market_data],
    )


def create_news_agent(guardrail_id: str | None = None) -> Agent:
    return Agent(
        model=_make_model(guardrail_id),
        system_prompt=(
            "You are a Financial News Analyst. Summarise recent news and "
            "provide sentiment analysis. Be objective."
        ),
        tools=[get_financial_news],
    )

Step 3- The Orchestrator & Agent-as-Tool Pattern

The orchestrator doesn't call specialist agents directly, it treats them as tools. This is the agent-as-tool pattern: each sub-agent is wrapped in a @tool function, so the orchestrator's model reasons about which specialist to consult, exactly like it would choose any other tool.

# agents/orchestrator.py
from strands import Agent, tool
from strands.models import BedrockModel
from agents.specialists import (
    create_portfolio_agent,
    create_market_data_agent,
    create_news_agent,
)
from tools.financial_tools import get_investment_recommendations


def _build_specialist_tools(guardrail_id: str | None):
    portfolio_agent = create_portfolio_agent(guardrail_id)
    market_agent   = create_market_data_agent(guardrail_id)
    news_agent     = create_news_agent(guardrail_id)

    @tool
    def ask_portfolio_agent(query: str) -> str:
        """Delegate a portfolio analysis or risk question to the Portfolio Specialist Agent."""
        return str(portfolio_agent(query))

    @tool
    def ask_market_data_agent(query: str) -> str:
        """Delegate a market data or pricing question to the Market Data Specialist Agent."""
        return str(market_agent(query))

    @tool
    def ask_news_agent(query: str) -> str:
        """Delegate a news or sentiment analysis question to the News Analyst Agent."""
        return str(news_agent(query))

    return [ask_portfolio_agent, ask_market_data_agent, ask_news_agent]


ORCHESTRATOR_PROMPT = """
You are a Senior Financial Advisor AI. Your role is to provide comprehensive,
personalised financial guidance. You have three specialist agents available:

- Portfolio Specialist: portfolio values, positions, risk metrics
- Market Data Specialist: prices, indices, volatility
- News Analyst: financial news and sentiment

Always delegate to the right specialist(s), then synthesise their findings
into a clear, actionable response for the client.
"""


def create_financial_advisor(
    guardrail_id: str | None = None,
    memory_context: str = "",
    model_id: str = "us.anthropic.claude-3-5-sonnet-20241022-v2:0",
) -> Agent:
    specialist_tools = _build_specialist_tools(guardrail_id)

    system_prompt = ORCHESTRATOR_PROMPT
    if memory_context:
        system_prompt += f"\n\n## Client Memory\n{memory_context}"

    model_kwargs = {"model_id": model_id, "region_name": "us-east-1"}
    if guardrail_id:
        model_kwargs.update({"guardrail_id": guardrail_id, "guardrail_version": "DRAFT"})

    return Agent(
        model=BedrockModel(**model_kwargs),
        system_prompt=system_prompt,
        tools=specialist_tools + [get_investment_recommendations],
    )

When the user asks "Should I rebalance my portfolio given today's market?", the orchestrator:

Calls ask_portfolio_agent → gets current holdings & risk score
Calls ask_market_data_agent → gets today's index moves
Calls ask_news_agent → gets relevant headlines
Synthesizes everything into a single coherent recommendation

Step 4- Persistent Memory Across Sessions

Without memory, every conversation starts cold. AgentCore Memory gives the agent a persistent, semantic store, the agent remembers past interactions and client preferences across sessions.

# memory/memory_manager.py
import boto3
from dataclasses import dataclass, field


class MemoryManager:
    """
    Wraps Amazon Bedrock AgentCore Memory with a local in-process fallback
    so the demo runs without any AWS credentials.
    """

    def __init__(
        self,
        memory_id: str | None = None,
        session_id: str | None = None,
        region: str = "us-east-1",
        use_local_fallback: bool = False,
    ):
        self.memory_id = memory_id
        self.session_id = session_id or "default"
        self.use_local = use_local_fallback or (memory_id is None)
        self._local_memory: list[dict] = []

        if not self.use_local:
            self._client = boto3.client("bedrock-agentcore", region_name=region)

    def save_turn(self, user_input: str, agent_response: str) -> None:
        """Persist a conversation turn."""
        if self.use_local:
            self._local_memory.append(
                {"user": user_input, "assistant": agent_response}
            )
            return

        self._client.save_memory(
            memoryId=self.memory_id,
            sessionId=self.session_id,
            messages=[
                {"role": "user",      "content": user_input},
                {"role": "assistant", "content": agent_response},
            ],
        )

    def get_recent_context(self, max_turns: int = 5, query: str | None = None) -> str:
        """Return a formatted string of recent memory to inject into the system prompt."""
        if self.use_local:
            recent = self._local_memory[-max_turns:]
            if not recent:
                return ""
            lines = ["Previous conversation context:"]
            for turn in recent:
                lines.append(f"User: {turn['user']}")
                lines.append(f"Assistant: {turn['assistant'][:200]}...")
            return "\n".join(lines)

        response = self._client.retrieve_memory(
            memoryId=self.memory_id,
            sessionId=self.session_id,
            query=query or "recent client interactions",
            maxResults=max_turns,
        )
        return "\n".join(r["content"] for r in response.get("results", []))

Memory context is injected into the orchestrator's system prompt on every turn:

memory = MemoryManager(use_local_fallback=True)  # swap to AWS for prod
context = memory.get_recent_context(query=user_input)

advisor = create_financial_advisor(memory_context=context)
response = advisor(user_input)

memory.save_turn(user_input, str(response))

Why this matters: "Persistent memory lets the agent remember past conversations and client preferences, enabling truly personalized financial guidance at scale."

Step 5- Compliance with Bedrock Guardrails

Financial applications have strict compliance requirements: no guaranteed return promises, no off-topic advice, PII must be redacted. Bedrock Guardrails handles all of this at the infrastructure level, zero code changes in your agent logic.

Guardrails are applied at both the input and output layers:

Input filter: blocks prompt injection, off-topic requests (medical, legal), and PII before the LLM ever sees them
Output filter: checks grounding, redacts any leaked PII, blocks harmful or hallucinated content

Here's how we configure it:

# guardrails/config.py
import boto3
from dataclasses import dataclass, field
from typing import Optional


@dataclass
class GuardrailsConfig:
    name: str = "financial-advisor-guardrail"
    content_filter_strength: str = "HIGH"

    denied_topics: list[dict] = field(default_factory=lambda: [
        {"name": "Non-Financial Advice",
         "definition": "Any advice outside personal finance, investments, or markets.",
         "examples": ["medical diagnosis", "legal advice", "relationship counselling"]},
        {"name": "Guaranteed Returns",
         "definition": "Claims that any investment guarantees specific returns.",
         "examples": ["guaranteed 20% return", "risk-free investment"]},
    ])

    pii_redaction_types: list[str] = field(default_factory=lambda: [
        "US_SOCIAL_SECURITY_NUMBER",
        "CREDIT_DEBIT_CARD_NUMBER",
        "US_BANK_ACCOUNT_NUMBER",
        "EMAIL",
        "PHONE",
        "NAME",
    ])

    blocked_words: list[str] = field(default_factory=lambda: [
        "guaranteed returns",
        "risk-free investment",
        "100% safe",
        "cannot lose",
    ])

    enable_grounding_check: bool = True
    grounding_threshold: float = 0.7


def get_or_create_guardrail(
    config: GuardrailsConfig | None = None,
    region: str = "us-east-1",
) -> Optional[str]:
    """Create (or retrieve existing) guardrail and return its ID."""
    config = config or GuardrailsConfig()
    client = boto3.client("bedrock", region_name=region)

    # Check if it already exists
    for g in client.list_guardrails().get("guardrails", []):
        if g["name"] == config.name:
            return g["id"]

    response = client.create_guardrail(
        name=config.name,
        contentPolicyConfig={
            "filtersConfig": [
                {"type": "SEXUAL",   "inputStrength": config.content_filter_strength,
                 "outputStrength": config.content_filter_strength},
                {"type": "VIOLENCE", "inputStrength": config.content_filter_strength,
                 "outputStrength": config.content_filter_strength},
                {"type": "HATE",     "inputStrength": config.content_filter_strength,
                 "outputStrength": config.content_filter_strength},
            ]
        },
        topicPolicyConfig={"topicsConfig": config.denied_topics},
        sensitiveInformationPolicyConfig={
            "piiEntitiesConfig": [
                {"type": t, "action": "ANONYMIZE"}
                for t in config.pii_redaction_types
            ]
        },
        wordPolicyConfig={
            "wordsConfig": [{"text": w} for w in config.blocked_words]
        },
        groundingPolicyConfig={
            "filtersConfig": [
                {"type": "GROUNDING",    "threshold": config.grounding_threshold},
                {"type": "RELEVANCE",    "threshold": config.grounding_threshold},
            ]
        } if config.enable_grounding_check else {},
    )
    return response["guardrailId"]

Attach the guardrail ID to the BedrockModel and every request, input AND output, is automatically screened.

Step 6- Deploy to Production with AgentCore Runtime

AgentCore Runtime is a serverless execution environment for agents. It handles auto-scaling, session management, health checks, and observability out of the box.

The deployment config lives in agentcore.json:

{
  "name": "financial-advisor-agent",
  "runtime": "python3.12",
  "handler": "main.handler",
  "model": {
    "provider": "bedrock",
    "model_id": "us.anthropic.claude-3-5-sonnet-20241022-v2:0"
  },
  "memory": {
    "enabled": true,
    "type": "agentcore",
    "session_ttl_days": 90
  },
  "guardrails": {
    "enabled": true,
    "guardrail_name": "financial-advisor-guardrail",
    "apply_to": ["input", "output"]
  },
  "scaling": {
    "min_instances": 1,
    "max_instances": 10,
    "target_concurrency": 5
  },
  "observability": {
    "tracing": "xray",
    "metrics": "cloudwatch",
    "log_level": "INFO"
  }
}

Three CLI commands take you from code to production:

# Develop locally with hot-reload
agentcore dev
# → Local agent running at http://localhost:8080

# Deploy to Amazon Bedrock AgentCore Runtime
agentcore deploy
# → Packaging agent... done
# → Provisioning CDK stack... done
# → Attaching guardrails... done
# → Configuring AgentCore Memory... done
# → Deployed! Endpoint: https://bedrock-agentcore.us-east-1.amazonaws.com/agents/fa-demo

# Invoke the deployed agent
agentcore invoke "What is the portfolio value for client ABC123?" --stream

Putting It All Together- Running the Demo

Clone the repo and run the demo locally (no AWS credentials required):

git clone https://github.com/awslabs/agentcore-samples
cd agentcore-samples/financial-advisor

pip install -r requirements.txt

# Local demo with mock data
python main.py

# Full AWS mode with real Bedrock, Memory, and Guardrails
python main.py --use-aws --enable-guardrails

# Interactive REPL
python main.py --interactive

The scripted demo walks through six representative turns:

[1/6] What is the total portfolio value for client ABC123?
  → Portfolio Specialist retrieves holdings + P&L

[2/6] What are the current prices for AAPL, GOOGL, and MSFT?
  → Market Data Specialist fetches live prices + 52w range

[3/6] What's the latest news about Apple and Microsoft?
  → News Analyst returns headlines + sentiment scores

[4/6] What's the risk level of my current portfolio?
  → Portfolio Specialist runs risk decomposition

[5/6] Based on everything, should I rebalance?
  → Orchestrator calls all three specialists + synthesises

[6/6] Given what I told you about my risk preference earlier, any concerns?
  → Memory-powered: agent recalls previous turns and personalises

Key Takeaways

The financial advisor demo shows how modern agent patterns come together in a coherent production architecture:

Strands SDK makes agents simple. The @tool decorator, Agent class, and BedrockModel eliminate most boilerplate. You describe your tools in plain Python; the SDK handles the rest.

Specialisation beats monoliths. Breaking the system into focused sub-agents — each with its own system prompt and tool set — produces sharper, more reliable answers than a single agent trying to do everything.

The agent-as-tool pattern is powerful. Wrapping sub-agents as @tool functions lets the orchestrator's model reason about delegation using the same mechanism it uses for everything else. No custom routing logic required.

Guardrails are infrastructure, not code. Attaching a Bedrock Guardrail to BedrockModel protects every single request- input AND output — without any changes to your agent logic. Compliance becomes a deployment concern, not a development one.

Memory makes agents personal. Injecting past conversations into the system prompt at runtime is simple but transformative. The agent genuinely remembers- and users notice immediately.

agentcore deploy is production-ready. Serverless execution, auto-scaling, integrated tracing, and health management are all included. Going from local dev to a live endpoint is three CLI commands.

Resources

Demo code: github.com/awslabs/agentcore-samples
Strands Agents SDK: github.com/strands-agents/sdk-python
Amazon Bedrock AgentCore docs: docs.aws.amazon.com/bedrock-agentcore
Amazon Bedrock Guardrails: docs.aws.amazon.com/bedrock/latest/userguide/guardrails.html
AWS Summit 2025 session: Use Agent Strategies to Streamline Complex Business Tasks

Built with ❤️ using open-source tools and AWS. Questions or feedback? Drop them in the comments below.

How I Built MzansiShopper, An AI-Powered Retail Assistant for Personalized Shopping

Adeline Makokha [AWS Hero] — Wed, 19 Nov 2025 15:33:17 +0000

Introduction
Imagine walking into a store and the assistant knows exactly what you’re looking for, even speaks your language. That’s the shopping experience I wanted to bring online in South Africa.

The Problem

There is limited personalization in retail in South Africa.
11 official languages hence creating accessibility barriers.
Consumers often feel excluded from digital tools.

I watched my mom struggle to shop online because everything was in English.

MzansiShopper is my solution to make retail more personalized and inclusive using AI.

South Africa's diverse languages and shopping needs inspired me to build a smart assistant that understands and recommends products in real time powered entirely by AWS services and deployed with Q- CLI for automation.

The Solution

My goal was simple, to build an AI assistant that delivers personalized product recommendations in multiple languages, helping customers find exactly what they need, while supporting digital inclusion in South Africa's retail sector.

But then came the challenge of building it. That's when I remembered Q CLI. Instead of starting from scratch, I leveraged Amazon Q for CLI, interacting with it right from my terminal to generate python code and bring MzansiShopper to life.

Stack Overview

MzansiShopper leverages AWS services:

Lex powers the conversational chat interface, understanding natural language.
Personalize generates real-time tailored product suggestions.
Translate enables multilinguals support, breaking language barriers.
DynamoDB securely stores user data and shopping history.
And I used Q- CLI for streamlined deployment and management of all these resources.

The process

Step by step Q-CLI created and built the project.
But it didn’t stop there! It also walked me through the installation process and how to run the app successfully.
Then… BOOM! It worked on the first try—no debugging, no errors, just pure Amazon Q magic.

The End Product

Deployment Process

Automating setup with CLI.
Handling data for recommendations.
Integrating Translate for multilingual support.

Lessons learned

Challenge: Managing multiple languages.
Win: CLI automation saved tons of time.
Surprise: How quickly AWS Personalize started delivering accurate results.

The Impact

MzansiShopper has enables digital inclusion.
Small retailers can now compete with bigger players.
Shoppers across languages feel seen and understood.

If you’re building with AWS, these tools are not for Silicon Valley startups, they’re for solving problems right here in Africa.

With the right tools, we can build solutions that are inclusive, scalable, and impactful.

MzansiShopper is a step towards making every South African feel at home in the digital economy.
Building with Amazon Q-CLI was an absolute blast! . It’s truly a game-changer fast, intuitive, and super helpful.
Supported environment for Amazon Q for command line
Install Amazon Q for command line in your own environment
Live Mzanzi App
Blog About Q-CLI

AI Agentic Kiro- Empowering Intelligent Agents

Adeline Makokha [AWS Hero] — Sat, 09 Aug 2025 09:56:43 +0000

What Is AI Agentic Kiro?

I built AI Agentic Kiro to let small, goal-driven programs called “agents”—handle cloud tasks automatically. Think of each agent like a little helper that:

Understands what you want (for example, “fetch today’s sales data”).
Does the work (runs code on AWS services).
Keeps track of what it’s done (logs results and errors).

How It’s Organized
It is organized in three steering files. Before any code runs, Kiro needs clear instructions. I found it easiest to keep three simple files in every project:

requirements.md
Lists exactly what the agent should do, in plain English.
design.md
Sketches the overall flow—step 1 leads to step 2, and so on.
tasks.md
Breaks the work into bite-sized tasks (for example, “download CSV,” “clean data,” “save to S3”).

Keeping these plain-text files first means you stay organized and teammates know exactly what to expect.

The Agent’s Life: Hooks You Can Use
Each agent goes through a simple lifetime in Kiro. At certain moments, you can “hook” in your own code to customize behavior:

on_init (when the agent starts):
Good for loading secrets or setting up connections.
before_task (right before a task runs):
Let’s you tweak the inputs—for example, add a timestamp or feature-flag.
after_task(right after completion):
Perfect for sending logs, metrics, or kicking off another process.
on_error (if something fails):
You can send an alert or retry.
on_shutdown (when all work is done):
Great for cleanup or sending a summary email.

In my first project, I used before_task to check if a file was large—if so, I sent it through a special processor.

Simple Architecture
Under the hood, here’s what happens:

You write your steering files.
An AWS-hosted MCP server holds those files and serves them to agents.
Kiro’s runtime (an AWS Lambda function) reads them.
It pulls tasks from an SQS queue.
Each task runs in Lambda or Step Functions.
Results and logs go to S3, DynamoDB, and CloudWatch.

That may sound like a lot, but Kiro hides most of it, your job is just to focus on the steering files and any custom hook code.

The MCP Server: Your Control Hub
The Management Control Plane (MCP) server is a lightweight component you deploy once per project. It:

Hosts your steering files (requirements.md, design.md, tasks.md).

Authenticates agents before they fetch updates.

Manages versioning, so you can roll back to a previous workflow design.

I run mine in a small EC2 instance behind an Application Load Balancer. Agents use a short-lived IAM role to call the MCP’s HTTPS endpoint and pull the latest instructions.

Use Cases

Daily Reports
Let an agent grab yesterday’s sales numbers and email you a summary every morning.
Auto-Cleanup
Agents monitor a folder in S3 and delete old files you no longer need.
Simple Chatbot
An agent reads support requests from a queue, checks a FAQ table, and posts answers.

Each of these starts by writing a few lines in requirements.md
no heavy coding to get going.

Tips for Getting Started

Write clear instructions first
Spend time on requirements.md, it’s your blueprint.
Keep hooks tiny
Focus hooks on one job: logging, alerting, or modifying data.
Use AWS free tier
You can experiment with Lambda, S3, and DynamoDB at no cost.
Test locally
Kiro comes with a simple emulator so you can run agents on your laptop before you deploy.

Try It Yourself
Visit Kiro website

Click on download button based on the operating system you are using.

Why Am a Tech Community Ambassador in East Africa!!

Adeline Makokha [AWS Hero] — Sun, 14 Jul 2024 14:44:07 +0000

WHAT KEEPS ME AWAKE!
I am deeply passionate about empowering youth to lead better lives. In today's rapidly evolving world, technology offers incredible opportunities for young people to improve their circumstances and contribute positively to their communities. I believe that by providing the right resources and support, we can unlock their full potential and help them build brighter futures.

WHAT THE NUMBERS ARE TELLING US
The tech industry is experiencing significant growth worldwide. Globally, the tech sector is expanding at a rate of 5% annually, creating millions of new jobs. In Africa, the potential is equally promising. By 2030, the continent is expected to have over 1.2 billion internet users, driving an increasing demand for tech professionals. This growth highlights the importance of equipping young people with the necessary skills to thrive in this dynamic field.

To succeed in the tech industry, obtaining relevant certifications is crucial. Some of the top certifications currently in demand include AWS Certified Solutions Architect, Google Certified Professional Cloud Architect, Microsoft Certified: Azure Solutions Architect Expert, and Cisco Certified Network Associate (CCNA). These certifications can significantly enhance career prospects and open doors to numerous opportunities.

Despite the increasing number of young people getting trained or certified in technology, there is still a significant gap between training and employment. In Africa, thousands of young tech enthusiasts are trained annually, but only a fraction secure jobs in their field. For instance, in Kenya, only about 20% of trained tech professionals find relevant employment, highlighting the need for better support systems.

WHY THE GAP

1. Skill gaps
Tech moves at lightning speed these days. It feels like there's always some new tool or programming language popping up. How's anyone supposed to keep up with all that? It's tough, especially when you're already juggling a full-time job and life stuff. Before you know it, your skills can start feeling a bit outdated.

2. Career stagnation
Getting stuck in a career rut is super common. You might wake up one day and realize you've been doing the same thing for years. Maybe you're not learning anything new, or you're just not excited about your work anymore. It's like being on a hamster wheel - you're moving, but not really going anywhere.

3. Limited access to vast job opportunities in the marketplace
There are so many cool jobs out there, but how do you even find out about them? If you don't have a big network, it's hard to hear about openings or get your foot in the door. And forget about those "hidden" jobs that never even get posted publicly.

A CASE FOR TECH COMMUNITIES
Tech communities is here to bridge this gap, young people need key things:

1. Networking

A tech community is like a big, friendly club for people who love technology. You get to meet lots of new people who are into the same stuff as you. It's a great way to make friends, find mentors, or even meet future work partners. You never know - the person you chat with at a meetup might end up being your next boss or business partner!

2. Knowledge sharing
In a tech community, everyone's learning from each other all the time. It's like a never-ending study group, but way more fun. If you're stuck on a problem, there's always someone who's been there before and can help out. And when you figure something out, you get to share it with others too. It's a give-and-take that helps everyone grow smarter together.

3. Exposure
Being part of a tech community is like opening a window to the whole tech world. You get to see and try out new technologies before everyone else. You hear about job openings first. You might even get chances to speak at events or show off projects you've worked on. It's a great way to get your name out there and be known as well as making a lasting contribution in the tech world .
4. Mentorship
Plus, mentors can be game-changers for your career. They can show you the ropes, help you avoid mistakes, and maybe even put in a good word for you with higher-ups. But finding a good mentor? That's like looking for a needle in a haystack if you don't have a solid network.

And let's be real - sometimes it's not what you know, it's who you know. When you're competing against a ton of other qualified people, having someone vouch for you can make all the difference. But if your network is small, you're missing out on those personal recommendations that could give you an edge.

CONCLUSION

So, here's the deal: We've got all these young techies out there, right? But they're kinda stuck between learning stuff and actually landing jobs. That's where tech communities come in. It's like creating a cool hangout spot where these techies can meet up, swap ideas, and find out about job openings.

I've seen it work, and let me tell you, it's pretty amazing. We're talking hundreds of young folks who've totally turned their lives around. And it's not just about them - they're out there making a real difference in their communities too.
That's why I'm all fired up about building more of these tech communities in East Africa, starting right here in Kenya. I'm telling you, this stuff is my passion. That is why it keeps me awake at night and also forms part of my breakfast.

I can't stop thinking about how much good we could do. It's like, every time I close my eyes, I see all these young people crushing it in tech jobs, you know?

Anyway, I've got loads more to say about why these tech communities are so awesome. But I'll save that for my next post. Don't wanna bore you all in one go! 😉
Stay tuned, folks. This is gonna be good!

REFERENCE
Top Certificates
AWS UserGroup Kenya

Leveraging Amazon Titan Text Premier for RAG AI in Software Testing

Adeline Makokha [AWS Hero] — Mon, 17 Jun 2024 06:07:26 +0000

Introduction
Amazon Titan Text Premier, now available through Amazon Bedrock, is a state-of-the-art generative AI model that can revolutionize various fields, including software testing. This article provides a detailed guide on how to implement Retrieval-Augmented Generation (RAG) and agent-based generative AI applications to enhance software testing processes, optimizing outcomes with these advanced technologies.

Understanding RAG and Agent-Based Generative AI
Retrieval-Augmented Generation (RAG)
RAG combines retrieval-based techniques with generative models to create systems capable of fetching relevant information from extensive data sets and using this context to generate high-quality responses. This is particularly useful for tasks requiring detailed and contextually accurate outputs, such as creating comprehensive test cases or documentation.

Agent-Based Generative AI
Agent-based generative AI employs autonomous agents powered by generative models to perform tasks like test case creation, scenario simulation, and software interaction. These agents can learn and adapt from their interactions, making software testing more efficient and effective.

How to Implement RAG and Agent-Based Generative AI in Software Testing
Step 1: Setting Up the Environment
1.1 Accessing Amazon Bedrock

Log into your AWS account and go to the Amazon Bedrock service.
Ensure you have the necessary permissions to use the Amazon Titan Text Premier model.
1.2 Provisioning the Titan Text Premier Model

Follow the AWS documentation to set up the Titan Text Premier model in your AWS environment.
Configure the model to meet your specific software testing needs.
Step 2: Creating a RAG System for Test Case Generation
2.1 Preparing the Data

Collect a comprehensive set of documents, including user manuals, past test cases, and bug reports.
Use a retrieval system like Elasticsearch or Amazon Kendra to index this data for efficient searching.
2.2 Implementing the RAG Framework

Develop a retrieval component that queries the indexed data based on test requirements.
Integrate the Titan Text Premier model to generate test cases using the retrieved information.
2.3 Automating Test Case Generation

Create automation scripts to streamline the process of retrieving and generating test cases.
Use these generated test cases to enhance your existing test suite for broader and more thorough testing.
Step 3: Deploying Agent-Based Generative AI for Dynamic Testing
3.1 Defining Agent Roles and Scenarios

Identify the types of agents needed, such as UI testers, API testers, and performance testers.
Define scenarios for these agents to cover, including edge cases and common user interactions.
3.2 Developing Agent Logic

Use the Titan Text Premier model to enable agents to dynamically generate and execute test scripts.
Implement logic for agents to adapt and learn from test results, improving their effectiveness over time.
3.3 Integrating with CI/CD Pipelines

Connect the agent-based testing system to your Continuous Integration/Continuous Deployment (CI/CD) pipeline.
Ensure agents can autonomously start tests, analyze results, and report issues, supporting continuous testing.
Benefits of Using Amazon Titan Text Premier in Software Testing
Comprehensive Test Coverage
RAG and generative AI allow for the creation of a wide range of test scenarios, including those that might be overlooked by human testers, ensuring thorough test coverage.

Enhanced Efficiency
Automating test case generation and execution reduces manual effort and speeds up the testing process, enabling testers to focus on more complex issues.

Continuous Improvement
Generative AI models learn from test results, continuously improving the accuracy and relevance of generated test cases and scenarios.

Scalability
Agent-based systems can easily scale to handle large test suites and extensive applications, providing robust testing capabilities without significant additional resources.

Conclusion
Integrating Amazon Titan Text Premier into your software testing framework with RAG and agent-based generative AI greatly enhances testing efficiency and effectiveness. By automating and optimizing test processes, organizations can achieve higher-quality software products with faster release cycles. Amazon Bedrock's advanced infrastructure and capabilities make it feasible and highly beneficial to implement these innovative AI techniques.

Embrace the future of software testing with Amazon Titan Text Premier and transform your testing strategies for superior results.

Leveraging Amazon Titan Text Premier for Agent-Based AI in Software Testing

Adeline Makokha [AWS Hero] — Sun, 26 May 2024 13:43:51 +0000

How to Implement RAG and Agent-Based Generative AI in Software Testing
Step 1: Setting Up the Environment
1.1 Accessing Amazon Bedrock

Log into your AWS account and go to the Amazon Bedrock service.
Ensure you have the necessary permissions to use the Amazon Titan Text Premier model.
1.2 Provisioning the Titan Text Premier Model

Follow the AWS documentation to set up the Titan Text Premier model in your AWS environment.
Configure the model to meet your specific software testing needs.

Step 2: Creating a RAG System for Test Case Generation
2.1 Preparing the Data

Develop a retrieval component that queries the indexed data based on test requirements.
Integrate the Titan Text Premier model to generate test cases using the retrieved information.

2.3 Automating Test Case Generation

Create automation scripts to streamline the process of retrieving and generating test cases.
Use these generated test cases to enhance your existing test suite for broader and more thorough testing.

Step 3: Deploying Agent-Based Generative AI for Dynamic Testing
3.1 Defining Agent Roles and Scenarios

Identify the types of agents needed, such as UI testers, API testers, and performance testers.
Define scenarios for these agents to cover, including edge cases and common user interactions.

3.2 Developing Agent Logic

Benefits of Using Amazon Titan Text Premier in Software Testing
Comprehensive Test Coverage
RAG and generative AI allow for the creation of a wide range of test scenarios, including those that might be overlooked by human testers, ensuring thorough test coverage.

Enhanced Efficiency
Automating test case generation and execution reduces manual effort and speeds up the testing process, enabling testers to focus on more complex issues.

Continuous Improvement
Generative AI models learn from test results, continuously improving the accuracy and relevance of generated test cases and scenarios.

Scalability
Agent-based systems can easily scale to handle large test suites and extensive applications, providing robust testing capabilities without significant additional resources.

Embrace the future of software testing with Amazon Titan Text Premier and transform your testing strategies for superior results.

REFERENCE
Build generative AI applications
AWS AI Service Cards

AWS Community Day Kenya

Adeline Makokha [AWS Hero] — Mon, 29 Apr 2024 11:12:57 +0000

The AWS User-group Kenya recently organized the first-ever AWS Community Day Kenya 2024, a big step forward for Kenya's tech scene. Held at KCA University on April 20th, the event brought together over 400 cloud enthusiasts, professionals, and businesses not only from Kenya but also neighboring countries like Uganda, Burundi, and Nigeria. The goal was simple: to share knowledge, discuss the latest trends, and explore how Amazon Web Services (AWS) can drive innovation in the cloud.

Big shout out to our amazing sponsors: Amazon Web Services, KCA University, Silicon Overdrive, QuCoon Limited, eMobilis Mobile Technology Institute, ELEVEN DEGREES CONSULTING LIMITED, Moringa School, Labmero Consulting, Dumela Corp, Whizlabs, YellowCard and Mesh.

The event boasted an impressive lineup of speakers, including Jeff Barr, Vice President & Chief Evangelist of AWS, who highlighted the global significance of the event. Eng. John Tanui, from Kenya's Ministry of ICT, and Dr. Aminah Zawedde, from Uganda's Ministry of ICT, and Robin Njiru shared insights into the region's digital transformation journey.

Eng. Tanui emphasized Kenya's commitment to digital advancement and its partnership with AWS to achieve ambitious goals outlined in Kenya Vision 2030. He highlighted how cloud technology can boost economic growth and create opportunities for Kenya's youth, citing the recent establishment of an AWS development center in Nairobi.

Dr. Zawedde echoed this sentiment, stressing the importance of empowering African youth to lead the technological revolution. She emphasized the role of events like the AWS Community Day in nurturing talent and fostering innovation, calling for its expansion to benefit more young people across the continent.

Robin Njiru's keynote shed light on the transformative impact of AWS technologies, emphasizing their potential to drive innovation, spur economic growth, and empower businesses across Sub-Saharan Africa. He spoke passionately about AWS's commitment to supporting the region's digital transformation journey, highlighting initiatives aimed at fostering talent development, enhancing technical skills, and accelerating cloud adoption.

In particular, He emphasized the role of events like the AWS Community Day in nurturing a vibrant and engaged community of cloud enthusiasts, professionals, and businesses. He commended the organizers and participants for their dedication and enthusiasm, recognizing their pivotal role in driving innovation and advancing technical expertise in the region.

WOMEN IN TECH PANEL DISCUSSION
There was a special session called Women in Tech. This session brought together successful women working in different tech roles to talk about their experiences and challenges in the industry.

One big topic they talked about was how hard it can be for women to balance work and personal life. They shared tips like being flexible with work hours, taking care of themselves, and getting support from family and colleagues.

The discussion showed how important it is to have a supportive environment for women in tech to do well both at work and in their personal lives. By sharing their stories, the panelists inspired others and helped make the tech community more inclusive.

ARTIFICIAL INTELLIGENCE & MACHINE LEARNING TRACK
Attendees had a chance to explore different tracks, each focusing on a specific area of cloud computing and technology. One standout track was all about AI and ML, where people got to dive into the world of artificial intelligence and machine learning. Led by experts, sessions covered topics like deep learning, language processing, and computer vision, showing how AI and ML are changing industries like healthcare and finance. Attendees also learned practical ways to use AWS tools like SageMaker to implement AI solutions.

DEVOPS TRACK

Another popular track was DevOps, which took a deep dive into how to streamline software development and operations. Participants learned about automation, continuous integration/delivery, and infrastructure as code. Through workshops and discussions, they discovered how AWS services like CodePipeline, CodeDeploy, and CloudFormation can make development faster and more efficient.

CYBERSECURITY TRACK

In the Cybersecurity track, attendees got a comprehensive look at how to keep cloud environments safe from cyber threats. Led by experts, sessions covered topics like identity management, data encryption, and threat detection. Attendees learned practical ways to use AWS services like IAM, KMS, and WAF to beef up security.

SUSTAINABILITY AND ENVIRONMENT TRACK

Lastly, the Sustainability track focused on how AWS is making a positive impact on the environment through its cloud infrastructure. Sessions explored AWS's efforts in renewable energy and reducing carbon footprint. Attendees learned how organizations can use AWS services to build eco-friendly solutions and heard inspiring stories of businesses integrating sustainability into their cloud projects.

AWS ONLINE DEEPRACER COMPETITION

As the AWS Community Day Kenya 2024 was winding down, things heated up for the AWS DeepRacer competition, capping off weeks of buildup and excitement. This fun event brought together people from different backgrounds, all pumped up to show off their machine learning and racing skills.

Leading up to the competition, participants spent more than a month getting ready, fine-tuning their DeepRacer models to perfection. With the help of mentors and AWS Solution Architect Sello Tseka, they tackled tricky algorithms and polished their racing strategies.

When the big moment finally arrived, the tension was thick in the air as the three winning teams emerged victorious. Their hard work paid off big time, and the DeepRacer competition not only showed off their tech skills but also brought the AWS community closer together.

This success story of the DeepRacer competition highlighted just how much innovation and creativity can come from machine learning and AI. As the day came to a close, participants left feeling proud and excited to keep exploring the endless possibilities of cloud computing and beyond.

CONCLUSION

As Kenya strides forward in its digital journey, events like the AWS Community Day play a crucial role in driving innovation and excellence in cloud computing. The AWS User-group Kenya has been instrumental in fostering a supportive community of AWS users and advocates, ultimately propelling Kenya towards a future powered by the endless possibilities of the cloud.

REFERENCE
AWS USERGROUP KENYA
JEFF BARR KEYNOTE
ROBIN NJIRU KEYNOTE
ENG. JOHN TANUI KEYNOTE
DR. AMINAH ZAWEDDE KEYNOTE

The Power of Generative AI for Tomorrow's Tech Careers

Adeline Makokha [AWS Hero] — Wed, 17 Apr 2024 10:36:15 +0000

In today's fast-paced world of technology, there's an incredible force shaking up how we work and what we can achieve: Generative Artificial Intelligence, or GenAI. It's not just another tool; it's like a spark igniting innovation, changing how we see and interact with technology.

Imagine this: humans teaming up with super-smart machines, creating endless possibilities. At the core of this change is Generative AI, a type of artificial intelligence that lets machines learn, adapt, and even create things all on their own. Unlike older AI systems that follow strict rules and patterns, Generative AI uses deep learning to come up with brand-new stuff, like pictures, music, stories, and more.

The really cool thing about Generative AI is how it gets our creative juices flowing and brings different people together. In the world of tech jobs, it's like a big shake-up, offering new roles and chances. Instead of just doing the same old stuff, professionals can now explore and invent, using GenAI to boost their skills and make their ideas real.

What's even better is how Generative AI is opening up technology to everyone. You don't need to be a coding whiz or a data expert to use AI anymore. With easy-to-use tools and platforms, people from all backgrounds can tap into GenAI's power. Whether you're an artist, a musician, a writer, or a scientist, Generative AI welcomes you to a world where creativity has no limits.

But there's more: Generative AI is shaking up how we think about work. As robots take over some tasks, it's time for us to team up with them and make the most of new technologies. Instead of worrying about losing our jobs, those who understand Generative AI are leading the charge, driving innovation and change.

The future of tech careers isn't about machines replacing us; it's about working together to make amazing things happen. By embracing Generative AI, we can explore new ideas, try out new things, and break free from old job roles. It's a chance to redefine what's possible and make technology work for us, not against us.
Conclusion
So let's dive into the world of Generative AI together! Whether you're a seasoned pro or just getting started, there's never been a better time to explore this exciting new frontier. Join us as we unlock the full potential of Generative AI and create a future where innovation knows no bounds.
REFERENCE
https://aws.amazon.com/generative-ai/

Generative AI with Bedrock and Party Rock

Adeline Makokha [AWS Hero] — Fri, 05 Apr 2024 14:22:02 +0000

Introduction:

In the ever-evolving landscape of artificial intelligence, the emergence of generative models has captured the imagination of researchers and enthusiasts alike. One such groundbreaking combination is the fusion of Bedrock and Party Rock, two powerful tools that promise to redefine the possibilities of generative AI. In this blog post, we'll explore the synergy between Bedrock and Party Rock, delving into their individual strengths and how their integration opens up new horizons in the world of AI-generated content.

Understanding Bedrock:

Bedrock, a robust framework for generative models, provides a solid foundation for creating AI systems that excel in tasks such as image generation, text completion, and more.

Its versatility lies in its ability to adapt to various domains, making it a go-to choice for developers seeking to push the boundaries of what AI can achieve. With Bedrock, creating sophisticated and realistic generative content becomes an exciting venture.

The Power of Party Rock:

On the other side of the spectrum, Party Rock introduces an element of creativity and dynamism to the generative AI landscape.
Developed as a toolkit for enhancing the expressiveness of AI-generated content, Party Rock injects a sense of spontaneity and flair into the creations. This tool is particularly adept at infusing generative models with a touch of randomness, making the output more engaging and unpredictable.

Synergy in Action:

When Bedrock and Party Rock join forces, the result is a harmonious blend of structure and creativity. Bedrock provides the robust foundation, ensuring the generated content maintains coherence and relevance, while Party Rock adds the spark of innovation and originality. The synergy between these two tools results in AI-generated content that not only meets the criteria of accuracy and relevance but also possesses a unique and captivating edge.

Applications in Various Domains:

The integration of Bedrock and Party Rock opens up a myriad of applications across different domains. From generating lifelike images for virtual environments to creating compelling narratives in the field of natural language processing, the combined power of these tools has the potential to revolutionize industries ranging from entertainment and gaming to education and beyond.

Challenges and Future Developments:

As with any technological advancement, the marriage of Bedrock and Party Rock comes with its set of challenges. Fine-tuning the balance between structure and creativity, addressing ethical considerations, and ensuring the responsible use of generative AI are among the key challenges that researchers and developers are actively working to overcome.

Looking ahead, the future developments in generative AI using Bedrock and Party Rock hold immense promise. As these tools continue to evolve, we can anticipate even more sophisticated and nuanced AI-generated content that pushes the boundaries of what we thought possible.

Conclusion:

Generative AI has reached new heights with the amalgamation of Bedrock and Party Rock. The union of structure and creativity not only enhances the capabilities of generative models but also opens up a world of possibilities across diverse industries. As researchers and developers continue to explore the potential of these tools, we find ourselves on the brink of a new era in AI, where the line between human creativity and machine-generated content becomes increasingly blurred. The future is indeed exciting, and the journey into the realm of generative AI with Bedrock and Party Rock is just beginning.

REFERENCE
https://aws.amazon.com/bedrock/

Say Hello to the Automated Testing Assistant by Party Rock

Adeline Makokha [AWS Hero] — Fri, 05 Apr 2024 12:40:23 +0000

In the ever-changing world of software development, finding effective ways to test and ensure reliability is an ongoing challenge. But fear not – the Automated Testing Assistant, powered by Party Rock, has arrived, promising to shake up the world of test automation. In this article, I'll dive into what makes the Automated Testing Assistant tick and how it's changing the game by generating test cases, managing data, creating checklists, offering insightful reports, optimizing code, handling exceptions, and even making bug reporting a breeze.

Features of Automated Testing Assistant
1.Generating Test Cases and Data

Say goodbye to the headache of creating test cases manually. The Automated Testing Assistant is a wizard at generating smart, all-encompassing test scenarios. Thanks to Party Rock's magic touch, it ensures your tests cover a wide range of situations, checking the resilience of your software under various conditions. And it doesn't stop there – it also helps whip up relevant test data to make sure your testing is as thorough as it gets.

2.Checklist Creation for Hassle-Free Testing

Efficient testing requires a solid plan, and the app is the expert checklist creator you need. Tailoring detailed checklists to your application, it becomes the roadmap for your testing journey, ensuring every nook and cranny of your software gets the attention it deserves.

3.Insightful Reports for Smarter Decisions
No more guesswork after running tests. Party Rock's Automated Testing Assistant goes the extra mile by delivering detailed reports that provide a 360-degree view of your test results. Developers and QA teams can quickly spot and tackle issues, armed with the kind of analytics that make continuous improvement a breeze.

4.Optimizing and Refactoring for Cleaner Code
Recognizing the importance of clean code in the testing process, the app lends a helping hand in optimizing and refactoring code snippets. Not only does this boost the efficiency of your test scripts, but it also contributes to the overall maintainability of your software.

5.Exception Handling Made Simple

Keeping your software stable is a priority, and the app is there to guide developers in setting up robust exception handling. Say goodbye to unexpected issues causing havoc during testing – this assistant has your back.

6.Seamless Bug Reporting

Spot a bug? Reporting it is now a walk in the park. The Automated Testing Assistant streamlines the bug reporting process with a user-friendly interface directly integrated into your testing environment. This means quicker bug resolution, paving the way for faster software delivery.

The Future of Software Testing
As we navigate the ever-changing landscape of software development, the Automated Testing Assistant powered by Party Rock emerges as your trusty companion. From generating test cases to optimizing code and everything in between, it's changing the way we approach test automation.

REFERENCE

AWS NewsBlog: https://aws.amazon.com/blogs/aws/build-ai-apps-with-partyrock-and-amazon-bedrock/

Conclusion
The Automated Testing Assistant is proof of Party Rock's transformative impact on testing processes. As technology marches forward, embracing innovative solutions like this promises to take the software development industry to new heights of precision, agility, and reliability. The road to automated excellence has never looked more promising and exciting!

PartyRock Website: https://partyrock.aws/
Check out the snapshot from the app here:https://partyrock.aws/u/Adele/c315JA0ho/Automated-Testing-Assistant

Tailoring AI Solutions for Your Business Success

Adeline Makokha [AWS Hero] — Sat, 02 Mar 2024 11:48:50 +0000

Introduction:

In the rapidly advancing landscape of artificial intelligence, AWS Bedrock stands out as a game-changer, offering a diverse range of features that empower businesses to harness the full potential of generative models.
This article delves into the key aspects of AWS Bedrock, exploring its broad choice of foundation models, the ability to customize model responses for business needs, private customization with proprietary data, knowledge bases, guardrails, batch mode, and model evaluation.

Broad Choice of Foundation Models:

AWS Bedrock provides a comprehensive selection of foundation models, laying the groundwork for various AI applications. Whether your focus is on natural language processing, image generation, or other tasks, Bedrock's array of models allows you to choose the foundation that aligns perfectly with your business objectives.

Customizing Model Responses for Your Business:

Tailoring AI responses to meet the specific needs of your business is a hallmark feature of AWS Bedrock.
The platform offers customization options that enable you to fine-tune model behavior, ensuring that the generated content aligns seamlessly with your brand, industry, or unique use case. You can use the raw data to maintain the accuracy of the foundation model for the domain through continued pre-training.

Privately Customize Models with Your Data:

Security and privacy are paramount concerns in the world of AI, and AWS Bedrock addresses these issues by allowing businesses to privately customize models with their proprietary data.
This ensures that sensitive information remains within the confines of your organization, providing a secure and compliant environment for AI model development.

Knowledge Bases for Amazon Bedrock:

Knowledge bases within AWS Bedrock serve as repositories of information, enhancing the model's understanding and decision-making capabilities.
Leveraging knowledge bases allows businesses to augment the generative process with contextually rich data, resulting in more sophisticated and context-aware AI responses.

Guardrails for Amazon Bedrock:

To ensure responsible and ethical AI use, AWS Bedrock includes guardrails that help guide the development and deployment of generative models.
These guardrails serve as checks and balances, promoting adherence to ethical standards and preventing unintended consequences in AI-generated content.

Batch Mode Amazon Bedrock:

The batch mode feature in AWS Bedrock facilitates the processing of multiple inputs simultaneously, streamlining workflows and improving efficiency.
This capability is particularly beneficial for businesses dealing with large datasets or requiring bulk processing of AI tasks.

Model Evaluation on Amazon Bedrock:

Ensuring the accuracy and effectiveness of generative models is essential, and AWS Bedrock simplifies this process with robust model evaluation tools.
Businesses can assess the performance of their AI models, refine them based on real-world data, and continuously improve the quality of generated content.
With Amazon Bedrock one can use the trained model to generate new images. for example image of Maasai village in Kenya.

Conclusion:

AWS Bedrock emerges as a powerful and flexible solution for businesses seeking to integrate generative AI into their operations.
It does the heavy lifting from the model customization process.
With its broad choice of foundation models, customization options, private customization with proprietary data, knowledge bases, guardrails, batch mode, and model evaluation features, AWS Bedrock empowers organizations to harness the true potential of AI while maintaining control, security, and ethical standards.
As businesses navigate the evolving landscape of AI, AWS Bedrock stands as a reliable foundation for success.

REFERENCE
https://aws.amazon.com/bedrock/

Amazon Elastic File System

Adeline Makokha [AWS Hero] — Wed, 12 Oct 2022 05:35:28 +0000

• Amazon EFS is a serverless, scalable, high-performance file system in the cloud.

• EFS file systems can be accessed by Amazon EC2 Linux instances, Amazon ECS, Amazon EKS, AWS Fargate, and AWS Lambda functions via a file system interface such as NFS protocol.

• Amazon EFS supports file system access semantics such as strong consistency and file locking.

• EFS file systems can automatically scale in storage to handle petabytes of data. With Bursting mode, the throughput available to a file system scales as a file system grows. Provisioned Throughput mode allows you to provision a constant file system throughput independent of the amount of data stored.

• EFS file systems can be concurrently accessed by thousands of compute services without sacrificing performance.

• Common use cases for EFS file systems include big data and analytics workloads, media processing workflows, content management, web serving, and home directories.

• Amazon EFS has four storage classes: Standard, Standard Infrequent Access, One Zone, and One Zone Infrequent Access

• You can create lifecycle management rules to move your data from standard storage classes to infrequent access storage classes.

• Every EFS file system object of Standard storage is redundantly stored across multiple AZs.

• EFS offers the ability to encrypt data at rest and in transit. Data encrypted at rest using AWS KMS for encryption keys. Data encryption in transit uses TLS 1.2

• To access EFS file systems from on-premises, you must have an AWS Direct Connect or AWS VPN connection between your on-
premises datacenter and your Amazon VPC.

Amazon FSx for Windows File Server
• Amazon FSx for Windows File Server is a fully managed, scalable file storage that is accessible over SMB protocol. 

• Since it is built on Windows Server, it natively supports administrative features such as user quotas, end-user file restore, and Microsoft Active Directory integration.

• FSx for WFS is accessible from Windows, Linux, and MacOS compute instances and devices. Thousands of compute instances and devices can access a file system concurrently.

• FSx  for WFS can connect your file system to Amazon EC2, Amazon ECS, VMware Cloud on AWS, Amazon WorkSpaces, and Amazon AppStream 2.0 instances.

• Every file system comes with a default Windows file share, named “share”.

• Common use cases for FSx for WFS include CRM, ERP, custom or .NET applications, home directories, data analytics, media and entertainment workflows, software build environments, and Microsoft SQL Server.

• You can access FSx file systems from your on-premises environment using an AWS Direct Connect or AWS VPN connection between your on-premises datacenter and your Amazon VPC. 

• You can choose the storage type for your file system: SSD storage for latency-sensitive workloads or workloads requiring the highest levels of IOPS/throughput. HDD storage for throughput-focused workloads that aren’t latency-sensitive.

• Every FSx for WFS ﬁle system has a throughput capacity that you conﬁgure when the ﬁle system is created and that you can change at any time.

• Each Windows File Server file system can store up to 64 TB of data. You can only manually increase the storage capacity.

• Your file system can be deployed in multiple AZs or a single AZ only. Multi-AZ file systems provide automatic failover.

• FSx for Windows File Server always encrypts your file system data and your backups at-rest using keys you manage through AWS KMS. Data-in-transit encryption uses SMB Kerberos session keys.

Amazon FSx for Lustre

• Amazon FSx for Lustre is a serverless file system that runs on Lustre ー an open-source, high-performance file system.

• The Lustre file system is designed for applications that require fast storage. FSx for Lustre file systems can scale to hundreds of GB/s of throughput and millions of IOPS. FSx for Lustre also supports concurrent access to the same file or directory from thousands of compute instances.

• Unlike EFS, storage capacity needs to be manually increased, and only every six hours can you do so.

• Amazon FSx for Lustre also integrates with Amazon S3, which lets you process cloud data sets with the Lustre high-performance file system.

• Common use cases for Lustre include machine learning, high-performance computing (HPC), video processing, financial modeling, genome sequencing, and electronic design automation (EDA).

• FSx for Lustre can only be used by Linux-based instances. To access your file system, you first install the open-source Lustre client on that instance. Then you mount your file system using standard Linux commands. Lustre file systems can also be used with Amazon EKS and AWS Batch.

FSx for Lustre provides two deployment options:

Scratch file systems are for temporary storage and shorter-term processing of data. Data is not replicated and does not persist if a file server fails.

Persistent file systems are for longer-term storage and workloads. The file servers are highly available, and data is automatically replicated within the AZ that is associated with the file system.

• FSx for Lustre always encrypts your file system data and your backups at-rest using keys you manage through AWS KMS. FSx encrypts data-in-transit when accessed from supported EC2 instances