DEV Community: Adeline Makokha [AWS Hero]

I Built a ML Churn Predictor in Minutes- Here's How Kiro Made It Possible

Adeline Makokha [AWS Hero] — Mon, 18 May 2026 12:25:13 +0000

Customer churn is one of the most expensive problems in the telecom industry. Acquiring a new customer costs 5–10× more than retaining an existing one, yet most companies only discover a customer has churned after they've already left. The goal of this project is to flip that, give analysts a tool to identify at-risk customers before they churn, so retention teams can act proactively.

What would normally take days of planning, scaffolding, and wiring together took a fraction of the time, because I built it with Kiro, an AI-powered development environment that thinks in specs, not just code completions.

In this article I'll walk through building a complete churn prediction web application from scratch using Python, Flask, scikit-learn, and Plotly. By the end you'll have a working app that:

Accepts CSV uploads of customer data
Runs a Random Forest churn prediction model
Visualises results with three interactive charts
Lets you browse, filter, and sort at-risk customers
Exports results to CSV for downstream use

How Kiro Accelerated This Build

Before diving into the code, it's worth explaining why this came together so fast.

Most AI coding tools are reactive meaning you write code, they autocomplete. Kiro works differently. It starts with a spec-driven workflow where you describe what you want to build, and Kiro helps you think through requirements, design, and implementation tasks before a single line of code is written.

Here's exactly how this project unfolded:

1. Requirements in minutes, not hours

I described the project in plain English, "a telecom customer churn prediction website using Python" and Kiro generated a full requirements document covering 7 requirement areas with precise, testable acceptance criteria in EARS format. Things like:

"IF a Dataset contains up to 10,000 Customer Records, THEN THE Predictor SHALL complete prediction within 30 seconds."

No ambiguity. No back-and-forth. Edge cases I hadn't even thought about, like what happens when tenure = 0, or when a CSV is valid but contains zero data rows, were already covered.

2. Technical design with 15 correctness properties

From the requirements, Kiro produced a full technical design document i.e, component interfaces with Python signatures, data models, an architecture diagram, Flask route table, and 15 formal correctness properties to be verified with property-based tests. For example:

"For any array of churn scores and any threshold in [0.0, 1.0], compute_churn_rate SHALL return exactly round((count of scores >= threshold / total count) * 100, 2)."

This is the kind of rigour that usually only happens on large teams with dedicated QA. Kiro baked it in from the start.

3. Implementation tasks, automatically sequenced

Kiro then broke the design into a dependency-ordered task list, 13 top-level tasks across 8 parallel waves, from project scaffolding through to integration tests. Each task referenced specific requirements for traceability.

4. Code generation that actually matches the spec

With the spec in place, Kiro generated all the Python modules, Flask routes, Jinja2 templates, JavaScript, and sample data and the code matched the design document precisely. No hallucinated APIs, no mismatched interfaces.

The result is a production-quality app with 146 passing tests (unit, integration, and property-based) generated from a single plain English description.

The takeaway: Kiro doesn't just write code faster. It helps you build the right thing by front-loading the thinking. The spec becomes the source of truth, and the code follows from it.

What We're Building

Here's the full feature set at a glance:

Feature	Details
CSV Upload	Validates format, size (≤50 MB), required columns, and row-level data quality
Churn Prediction	Random Forest model, configurable threshold (default 0.5)
Dashboard	Summary stats + 3 Plotly charts
At-Risk Table	Paginated (25/page), sortable, filterable
Export	Download results as CSV
Model Info	Displays model name, version, and training date

Architecture Overview

The app follows a clean separation of concerns. Each responsibility lives in its own module:

Request flows:

Upload → Validator checks the file → valid rows stored in AppState
Predict → Predictor scores every row → Visualizer builds chart specs → stored in AppState
Export → Exporter serialises results → streamed as file download
Startup → ModelLoader loads model.joblib once; if it fails, prediction is disabled

Project Structure

telecom-churn-app/
├── app.py               # Flask routes and AppState
├── validator.py         # CSV upload validation
├── predictor.py         # Churn scoring
├── visualizer.py        # Plotly chart builders
├── exporter.py          # CSV export
├── model_loader.py      # joblib model loading
├── table_helpers.py     # Pagination, sort, filter
├── generate_model.py    # One-time model training script
├── requirements.txt
├── data/
│   ├── sample_customers.csv   # 200 rows
│   └── sample_small.csv       # 20 rows for quick testing
├── templates/
│   ├── base.html
│   └── dashboard.html
└── static/
    └── app.js

Getting Started

Prerequisites

Python 3.11+
pip

Install dependencies

pip install -r requirements.txt

requirements.txt:

Flask==3.0.3
pandas==2.2.2
numpy==1.26.4
scikit-learn==1.5.0
joblib==1.4.2
plotly==5.22.0
pytest==8.2.2
hypothesis==6.103.1

Generate the model

python generate_model.py
# → Model saved to model.joblib

Run the app

python app.py
# → Running on http://localhost:5000

The Data

The app expects a CSV with these five columns:

Column	Type	Rules
`customer_id`	string	Required
`tenure`	numeric	0 – 999 (months)
`monthly_charges`	numeric	> 0
`total_charges`	numeric	> 0
`contract_type`	string	"Month-to-month", "One year", "Two year"

A sample row from data/sample_small.csv:

customer_id,tenure,monthly_charges,total_charges,contract_type
CUST0001,69,113.04,7560.84,One year
CUST0004,41,59.11,2325.40,Month-to-month
CUST0007,68,113.62,7797.64,Two year

Step 1: Training the Model (`generate_model.py`)

We generate 1,000 rows of synthetic training data where churn probability is driven by three realistic signals i.e, short tenure, high monthly charges, and month-to-month contracts.

def generate_training_data(n: int = 1000, seed: int = 42) -> pd.DataFrame:
    rng = np.random.default_rng(seed)

    tenure = rng.integers(0, 73, size=n)
    monthly_charges = rng.uniform(20.0, 120.0, size=n).round(2)
    total_charges = (tenure * monthly_charges * rng.uniform(0.95, 1.05, size=n)).round(2)

    contract_type = rng.choice(
        ["Month-to-month", "One year", "Two year"],
        size=n,
        p=[0.5, 0.3, 0.2]
    )

    # Churn probability: higher for short tenure, month-to-month, high charges
    churn_prob = (
        0.4 * (1 - tenure / 72)
        + 0.3 * (monthly_charges - 20) / 100
        + 0.3 * (contract_type == "Month-to-month").astype(float)
    )
    churn_prob = np.clip(churn_prob, 0.05, 0.95)
    churn = rng.binomial(1, churn_prob, size=n)
    ...

After training a RandomForestClassifier, we attach metadata directly to the model object before saving with joblib:

model.metadata = {
    "name": "RandomForestChurnModel",
    "version": "1.0.0",
    "training_date": "2024-01-15",
}
joblib.dump(model, "model.joblib")

This keeps the model and its metadata in a single file and no separate config needed.

Step 2: Loading the Model (`model_loader.py`)

The model is loaded once at startup. If the file is missing or corrupt, the app enters a degraded state where prediction is disabled but everything else still works.

@dataclass
class ModelMetadata:
    name: str
    version: str
    training_date: date  # displayed as ISO 8601 YYYY-MM-DD

@dataclass
class LoadedModel:
    model: object
    metadata: ModelMetadata

class ModelLoadError(Exception):
    pass

def load_model(path: str) -> LoadedModel:
    try:
        model = joblib.load(path)
    except FileNotFoundError:
        raise ModelLoadError(f"Model file not found: {path}")
    except Exception as e:
        raise ModelLoadError(f"Failed to load model: {e}")

    raw_meta = model.metadata
    training_date = date.fromisoformat(raw_meta["training_date"])

    return LoadedModel(
        model=model,
        metadata=ModelMetadata(
            name=raw_meta["name"],
            version=raw_meta["version"],
            training_date=training_date,
        )
    )

In app.py, this runs before the first request is served:

app_state = AppState()

def _load_model_on_startup():
    try:
        app_state.loaded_model = load_model(MODEL_PATH)
    except ModelLoadError as e:
        app_state.model_load_error = str(e)

_load_model_on_startup()

Step 3: Validating Uploads (`validator.py`)

The validator runs a multi-stage pipeline. Each stage can fail fast with a clear error message:

The row-level rules are:

monthly_charges and total_charges must be numeric and > 0
tenure must be numeric, ≥ 0, and ≤ 999 (tenure = 0 is valid)

def _validate_rows(df: pd.DataFrame) -> tuple[pd.DataFrame, int]:
    work_df = df.copy()
    work_df["_tenure_num"]  = pd.to_numeric(work_df["tenure"],          errors="coerce")
    work_df["_monthly_num"] = pd.to_numeric(work_df["monthly_charges"], errors="coerce")
    work_df["_total_num"]   = pd.to_numeric(work_df["total_charges"],   errors="coerce")

    valid_mask = (
        work_df["_tenure_num"].notna()
        & (work_df["_tenure_num"] >= 0)
        & (work_df["_tenure_num"] <= 999)
        & work_df["_monthly_num"].notna()
        & (work_df["_monthly_num"] > 0)
        & work_df["_total_num"].notna()
        & (work_df["_total_num"] > 0)
    )

    valid_df = df[valid_mask].copy()
    invalid_count = int((~valid_mask).sum())
    return valid_df, invalid_count

If some rows are invalid but at least one is valid, the app warns the user and proceeds with the clean rows. If all rows are invalid, prediction is blocked.

The ValidationResult dataclass carries everything the route handler needs:

@dataclass
class ValidationResult:
    success: bool
    error_message: str | None = None
    warning_message: str | None = None
    dataframe: pd.DataFrame | None = None
    total_rows: int = 0
    valid_rows: int = 0
    invalid_rows: int = 0

Step 4: Running Predictions (`predictor.py`)

The predictor one-hot encodes contract_type to match the training feature set, then calls predict_proba to get churn probabilities:

def predict(df: pd.DataFrame, model, threshold: float = 0.5) -> PredictionResult:
    try:
        feature_df = df[["tenure", "monthly_charges", "total_charges", "contract_type"]].copy()
        feature_df = pd.get_dummies(feature_df, columns=["contract_type"])

        # Ensure all contract type columns exist even if not in this batch
        for col in ["contract_type_Month-to-month", "contract_type_One year", "contract_type_Two year"]:
            if col not in feature_df.columns:
                feature_df[col] = 0

        feature_cols = ["tenure", "monthly_charges", "total_charges",
                        "contract_type_Month-to-month", "contract_type_One year", "contract_type_Two year"]
        X = feature_df[feature_cols].astype(float)

        probas = model.predict_proba(X)
        scores = probas[:, 1]  # probability of churn

        return PredictionResult(success=True, scores=scores,
                                customer_ids=df["customer_id"].tolist(),
                                threshold=threshold)
    except Exception as e:
        return PredictionResult(success=False, error_message=str(e), threshold=threshold)

The churn rate formula is explicit and deterministic:

def compute_churn_rate(scores: np.ndarray, threshold: float) -> float:
    at_risk_count = int(np.sum(scores >= threshold))
    return round((at_risk_count / len(scores)) * 100, 2)

Step 5: Visualising Results (`visualizer.py`)

Three Plotly charts are built server-side and serialised to JSON, then rendered client-side with Plotly.newPlot. This keeps the server stateless with respect to chart rendering.

Chart 1: At-Risk vs Non-At-Risk bar chart

At-Risk  ████████████████  87
Non-Risk ████████████████████████████████  113

Chart 2: Churn Score Distribution (histogram)

Exactly 10 bins of width 0.1 spanning [0.0, 1.0]:

def build_score_histogram(scores: np.ndarray) -> dict:
    bin_edges = np.linspace(0.0, 1.0, 11)  # 11 edges = 10 bins
    counts, _ = np.histogram(scores, bins=bin_edges)
    bin_centers = [(bin_edges[i] + bin_edges[i+1]) / 2 for i in range(10)]

    fig = go.Figure(data=[go.Bar(x=bin_centers, y=counts.tolist(), width=0.09)])
    fig.update_layout(title="Churn Score Distribution", ...)
    return fig.to_dict()

Chart 3: Churn Rate by Contract Type

Month-to-month  ████████████████████████  62.4%
One year        ████████  21.3%
Two year        ████  10.1%

Step 6: The Flask Application (`app.py`)

All mutable state lives in a single AppState dataclass — a simple singleton for single-user deployments:

@dataclass
class AppState:
    dataset: pd.DataFrame | None = None
    prediction_result: PredictionResult | None = None
    threshold: float = 0.5
    loaded_model: LoadedModel | None = None
    model_load_error: str | None = None
    chart_specs: dict | None = None

The six routes map cleanly to user actions:

Route	Method	Action
`GET /`	GET	Redirect to dashboard
`GET /dashboard`	GET	Render main page
`POST /upload`	POST	Validate and store CSV
`POST /predict`	POST	Run prediction
`POST /threshold`	POST	Update churn threshold
`GET /export`	GET	Stream CSV download

The upload route shows the validation pipeline in action:

@app.route("/upload", methods=["POST"])
def upload():
    uploaded_file = request.files["file"]
    file_bytes = uploaded_file.read()
    result = validate_upload(file_bytes, uploaded_file.filename, len(file_bytes))

    if not result.success:
        flash(result.error_message, "error")
        return redirect(url_for("dashboard"))

    # Clear previous results when new data is uploaded
    app_state.dataset = result.dataframe
    app_state.prediction_result = None
    app_state.chart_specs = None

    if result.warning_message:
        flash(result.warning_message, "warning")

    flash(f"File uploaded successfully. {result.valid_rows} customer record(s) loaded.", "success")
    return redirect(url_for("dashboard"))

The threshold route validates the range before accepting the new value:

@app.route("/threshold", methods=["POST"])
def update_threshold():
    threshold_val = float(request.form.get("threshold", ""))

    if not validate_threshold(threshold_val):
        flash(f"Threshold {threshold_val} is out of range. Valid range is [0.0, 1.0].", "error")
        return redirect(url_for("dashboard"))

    app_state.threshold = threshold_val
    # Rebuild charts immediately if results exist
    if app_state.prediction_result and app_state.prediction_result.success:
        app_state.prediction_result.threshold = threshold_val
        app_state.chart_specs = _build_chart_specs(app_state.dataset, app_state.prediction_result)

    flash(f"Threshold updated to {threshold_val}.", "success")
    return redirect(url_for("dashboard"))

Step 7: The Dashboard UI

The dashboard uses a two-column Bootstrap 5 layout: a narrow left sidebar for controls, and a wide right panel for results.

Chart data is injected into the page as JSON and rendered by Plotly client-side:

<!-- In dashboard.html -->
{% if has_results %}
<script id="chart-data" type="application/json">{{ chart_data_json | safe }}</script>
<script id="table-data" type="application/json">{{ at_risk_table_json | safe }}</script>
{% endif %}

// In app.js
function renderCharts() {
  const chartData = JSON.parse(document.getElementById('chart-data').textContent);
  const config = { responsive: true, displayModeBar: false };

  Plotly.newPlot('chart-at-risk',   chartData.at_risk_bar.data,    chartData.at_risk_bar.layout,    config);
  Plotly.newPlot('chart-histogram', chartData.score_histogram.data, chartData.score_histogram.layout, config);
  Plotly.newPlot('chart-contract',  chartData.contract_type.data,   chartData.contract_type.layout,   config);
}

Step 8: At-Risk Table: Pagination, Sort, Filter

The table helpers are pure Python functions, independently testable and reusable:

# table_helpers.py

def paginate(records: list, page: int, page_size: int = 25) -> list:
    start = (page - 1) * page_size
    return records[start : start + page_size]

def sort_records(records: list, column: str, direction: str) -> list:
    reverse = direction.lower() == "desc"
    return sorted(records, key=lambda r: (r.get(column) is None, r.get(column)), reverse=reverse)

def filter_records(records: list, search_term: str) -> list:
    if not search_term:
        return records
    term = search_term.lower()
    return [r for r in records if term in str(r.get("customer_id", "")).lower()]

The client-side JavaScript mirrors this logic for instant interactivity without round-trips:

// Sort on column header click
document.querySelectorAll('#atRiskTable thead th[data-col]').forEach(th => {
  th.addEventListener('click', function () {
    const col = this.getAttribute('data-col');
    sortDirection = (sortColumn === col && sortDirection === 'asc') ? 'desc' : 'asc';
    sortColumn = col;
    currentPage = 1;
    renderTable();
  });
});

// Filter on search input
document.getElementById('tableSearch').addEventListener('input', function () {
  const term = this.value.toLowerCase();
  filteredRecords = allRecords.filter(r =>
    String(r.customer_id || '').toLowerCase().includes(term)
  );
  currentPage = 1;
  renderTable();
});

Step 9: Exporting Results (`exporter.py`)

The export produces a clean CSV with a fixed column order. One detail worth noting: pandas serialises Python booleans as True/False (capitalised) by default, but the spec requires lowercase true/false. We handle this explicitly:

EXPORT_COLUMNS = ["customer_id", "churn_score", "is_at_risk",
                  "contract_type", "tenure", "monthly_charges"]

def build_export_dataframe(df, scores, at_risk_flags) -> pd.DataFrame:
    return pd.DataFrame({
        "customer_id":     df["customer_id"].values,
        "churn_score":     np.round(scores, 4),       # 4 decimal places
        "is_at_risk":      at_risk_flags.astype(bool),
        "contract_type":   df["contract_type"].values,
        "tenure":          df["tenure"].values,
        "monthly_charges": df["monthly_charges"].values,
    })[EXPORT_COLUMNS]

def to_csv_bytes(export_df: pd.DataFrame) -> bytes:
    out_df = export_df.copy()
    out_df["is_at_risk"] = out_df["is_at_risk"].map({True: "true", False: "false"})
    return out_df.to_csv(index=False).encode("utf-8")

Sample export output:

customer_id,churn_score,is_at_risk,contract_type,tenure,monthly_charges
CUST0004,0.8231,true,Month-to-month,41,59.11
CUST0005,0.7654,true,Month-to-month,12,47.03
CUST0009,0.1203,false,One year,70,97.46

Testing Strategy

The project uses two complementary testing approaches.

Example-based tests (pytest)

These cover specific scenarios and exact error messages:

# tests/unit/test_validator.py
def test_rejects_non_csv_file():
    result = validate_upload(b"some data", "data.xlsx", 100)
    assert result.success is False
    assert "xlsx" in result.error_message

def test_tenure_zero_is_valid():
    csv = b"customer_id,tenure,monthly_charges,total_charges,contract_type\n"
    csv += b"C001,0,50.0,0.01,Month-to-month\n"
    result = validate_upload(csv, "test.csv", len(csv))
    assert result.success is True
    assert result.valid_rows == 1

Property-based tests (Hypothesis)

These verify universal correctness properties across thousands of generated inputs:

# tests/property/test_predictor_properties.py
from hypothesis import given, settings
import hypothesis.strategies as st

@given(
    scores=st.lists(st.floats(0.0, 1.0), min_size=1).map(np.array),
    threshold=st.floats(0.0, 1.0)
)
@settings(max_examples=200)
def test_classify_at_risk_consistency(scores, threshold):
    """
    Property 2: For any scores and threshold, classify_at_risk returns
    True iff score >= threshold — including identical scores.
    """
    flags = classify_at_risk(scores, threshold)
    for score, flag in zip(scores, flags):
        assert flag == (score >= threshold)

@given(st.integers(min_value=0))
def test_file_size_boundary(size):
    """
    Property 9: _check_file_size returns True iff size <= 52,428,800.
    """
    result = _check_file_size(size)
    assert result == (size <= 52_428_800)

Key Design Decisions

Why a singleton AppState instead of Flask sessions?
Sessions are limited to ~4 KB (cookie storage) and can't hold DataFrames. For a single-user analytics tool, a module-level singleton is simpler and more practical than a database or Redis cache.

Why Plotly JSON instead of server-rendered images?
Plotly charts are interactive, users can hover, zoom, and pan. Serialising chart specs as JSON and rendering client-side means the server doesn't need a headless browser or image generation library.

Why separate table_helpers.py?
Keeping pagination, sort, and filter as pure functions makes them trivially testable without spinning up a Flask test client. The JavaScript mirrors the same logic for instant client-side interactivity.

Why one-hot encode at prediction time?
The uploaded CSV may not contain all three contract types. Encoding at prediction time and filling missing columns with 0 ensures the feature vector always matches what the model was trained on.

Running the Full App

# 1. Install dependencies
pip install -r requirements.txt

# 2. Train and save the model
python generate_model.py

# 3. Start the server
python app.py

Open http://localhost:5000, upload data/sample_customers.csv, and click Predict Churn.

You should see:

Summary stats (total customers, at-risk count, churn rate %)
Three interactive Plotly charts
A paginated, sortable, filterable table of at-risk customers
An export button to download the full results as CSV

What's Next

A few natural extensions from here:

User authentication - add Flask-Login for multi-user support with per-user state
Model retraining - add an admin route to upload new training data and retrain in-place
Scheduled batch jobs - use Celery + Redis to run predictions on a schedule and email results
Database persistence - swap the in-memory AppState for SQLAlchemy + PostgreSQL to persist results across restarts
SHAP explanations - add feature importance explanations per customer using the shap library

Source Code

The full source is available on GitHub: Agentic AI Kiro

The project includes:

All Python modules with docstrings
Sample CSV data (200 rows)
generate_model.py to reproduce the model
Unit, integration, and property-based tests

Try Kiro Yourself

If you want to build something like this or anything else - Kiro is worth trying. The spec-driven workflow changes how you approach a project. Instead of diving straight into code and figuring out the design as you go, you start with a clear picture of what you're building and why. The code becomes the easy part.

The entire requirements document, technical design, task list, and implementation for this project came from a single prompt. That's the difference.

Built with Flask, pandas, scikit-learn, and Plotly. Spec-driven development powered by Kiro. Tested with pytest and Hypothesis.

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