AWS-Architekturen mit MCP-Servern und Strands Agents bauen

In der sich rasant entwickelnden Welt der Cloud-Architektur und KI-gestützten Entwicklung krempeln zwei Technologien grundlegend um, wie wir AWS-Lösungen bauen und ausrollen: Model Context Protocol (MCP) Server und Strands Agents.

MCP-Server bieten einen standardisierten Weg, Large Language Models (LLMs) an externe Datenquellen und Tools anzubinden. Sie schlagen die Brücke zwischen KI-Modellen und unterschiedlichsten Diensten und ermöglichen die nahtlose Integration von Dokumentationen, APIs und Cloud-Ressourcen. Im AWS-Umfeld liefern MCP-Server direkten Zugriff auf AWS-Dokumentation, Service-APIs und Architektur-Tools.

Strands Agents sind intelligente Orchestrierungs-Frameworks, die LLMs nutzen, um komplexe Workflows zu automatisieren. Sie analysieren Aufgaben, treffen Entscheidungen und führen mehrstufige Prozesse weitgehend ohne menschliches Zutun aus. In Kombination mit MCP-Servern werden Strands Agents zu enorm leistungsfähigen Werkzeugen für Cloud-Architektur und Automatisierung.

Diese Kombination ist ein klarer Sprung nach vorn gegenüber klassischen Ansätzen der Agenten-Programmierung. Statt umfangreichen, komplexen Code für API-Aufrufe, Fehlerbehandlung und Workflow-Orchestrierung zu schreiben, beschreiben Entwickler ihre Absicht einfach in natürlicher Sprache und überlassen die Implementierungsdetails den Agenten. Das verkürzt die Entwicklungszeit drastisch und öffnet Cloud-Architektur für einen deutlich breiteren Kreis von Entwicklern.

Hier ein Beispiel für ein Architekturdiagramm einer Website, die AWS Lambda für eine auf S3 gehostete statische Website nutzt. Erstellt wurde es im Zusammenspiel von MCP-Servern und Strands Agents.

Prompt: "Get the documentation for AWS Lambda then create a diagram of a website that uses AWS Lambda for a static website hosted on S3"

Werfen wir einen Blick auf den Code, mit dem das obige Diagramm erstellt wurde. Er zeigt, wie schlagkräftig MCP-Server zusammen mit Strands Agents bei der Generierung von AWS-Architekturen sind:

from mcp import StdioServerParameters, stdio_client
from strands import Agent
from strands.models import BedrockModel
from strands.tools.mcp import MCPClient

aws_docs_client = MCPClient(
    lambda: stdio_client(
        StdioServerParameters(
            command="uvx", args=["awslabs.aws-documentation-mcp-server@latest"]
        )
    )
)
aws_diag_client = MCPClient(
    lambda: stdio_client(
        StdioServerParameters(
            command="uvx", args=["awslabs.aws-diagram-mcp-server@latest"]
        )
    )
)
bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-3-5-haiku-20241022-v1:0",
    temperature=0.7,
)
SYSTEM_PROMPT = """
You are an expert AWS Certified Solutions Architect. Your role is to help customers understand best practices on building on AWS. You can query the AWS Documentation and generate diagrams. Make sure to tell the customer the full file path of the diagram.
"""
with aws_diag_client, aws_docs_client:
    all_tools = aws_diag_client.list_tools_sync() + aws_docs_client.list_tools_sync()
    agent = Agent(tools=all_tools, model=bedrock_model, system_prompt=SYSTEM_PROMPT)
    response = agent(
        "Get the documentation for AWS Lambda then create a diagram of a website that uses AWS Lambda for a static website hosted on S3"
    )

Initialisierung des MCP-Clients:

aws_docs_client = MCPClient(
    lambda: stdio_client(
        StdioServerParameters(
            command="uvx", args=["awslabs.aws-documentation-mcp-server@latest"]
        )
    )
)

Hier wird ein MCP-Client erstellt, der sich mit dem offiziellen AWS-Dokumentationsserver verbindet. Der Befehl uvx lädt die jeweils neueste Version des AWS-Dokumentations-MCP-Servers dynamisch und führt sie aus – so haben Sie immer die aktuellste AWS-Dokumentation zur Hand.

Client zur Diagrammerstellung:

aws_diag_client = MCPClient(
    lambda: stdio_client(
        StdioServerParameters(
            command="uvx", args=["awslabs.aws-diagram-mcp-server@latest"]
        )
    )
)

Analog dazu entsteht hier ein Client für den AWS-Diagramm-MCP-Server, der visuelle Darstellungen von AWS-Architekturen programmatisch erzeugt.

Modellkonfiguration:

bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-3-5-haiku-20241022-v1:0",
    temperature=0.7,
)

An dieser Stelle wird das zugrunde liegende LLM konfiguriert – in diesem Fall Claude 3.5 Haiku über AWS Bedrock. Ein Temperature-Wert von 0,7 sorgt für eine gute Balance zwischen Kreativität und Konsistenz bei Architekturentscheidungen. Strands Agents verbinden sich zwar standardmäßig mit Bedrock, lassen sich aber auch mit zahlreichen Drittanbietern wie Gemini, Anthropic oder OpenAI betreiben.

Agenten-Orchestrierung:

with aws_diag_client, aws_docs_client:
    all_tools = aws_diag_client.list_tools_sync() + aws_docs_client.list_tools_sync()
    agent = Agent(tools=all_tools, model=bedrock_model, system_prompt=SYSTEM_PROMPT)

Jetzt kommen die Strands Agents ins Spiel. Der Agent erkennt automatisch alle verfügbaren Tools beider MCP-Server und bindet sie nahtlos ein. Der System-Prompt legt seine Rolle als AWS Solutions Architect fest und liefert ihm den nötigen Kontext für fundierte Architekturentscheidungen.

Ausführung in natürlicher Sprache:

response = agent(
    "Get the documentation for AWS Lambda then create a diagram of a website that uses AWS Lambda for a static website hosted on S3"
)

Diese eine Zeile zeigt, wie wirkungsvoll der Ansatz ist. Statt komplexen Code zu schreiben, der Dokumentations-APIs abfragt, Antworten parst und Diagramme erzeugt, beschreiben wir in natürlicher Sprache, was wir wollen. Den Rest erledigt der Agent im Hintergrund.

Klassische Agenten-Entwicklung erfordert in mehreren entscheidenden Bereichen umfangreichen Boilerplate-Code:

Manuelle API-Integration: Entwickler verbringen typischerweise viel Zeit damit, HTTP-Clients zu implementieren, Authentifizierung zu handhaben, Antworten zu parsen und Rate Limits für jeden anzubindenden Dienst zu verwalten.

Fehlerbehandlung und Retry-Logik: Robuste Agenten brauchen ausgefeilte Fehlerbehandlung, Exponential Backoff, Circuit Breaker und Retry-Mechanismen, um zuverlässig zu laufen.

Workflow-Orchestrierung: Mehrstufige Prozesse zu koordinieren, verlangt komplexes State Management, bedingte Verzweigungen und eine durchdachte Aufgabenplanung.

Tool-Erkennung und -Verwaltung: Klassische Ansätze setzen voraus, dass verfügbare Tools und ihre Schnittstellen fest im Code verdrahtet sind – das macht das System starr und schwer erweiterbar.

Der Ansatz aus Strands und MCP bringt dagegen mehrere zentrale Vorteile mit:

Weniger Boilerplate: Das Framework übernimmt die Low-Level-Infrastruktur, sodass sich Entwickler auf Geschäftslogik und Architekturentscheidungen konzentrieren können.

Dynamische Tool-Erkennung: MCP-Server können ihre Fähigkeiten dynamisch bekanntmachen, und Strands Agents erkennen und nutzen neue Tools ganz ohne Codeänderungen.

Schnittstelle in natürlicher Sprache: Statt prozeduralen Code zu schreiben, beschreiben Entwickler ihre Absicht in natürlicher Sprache – das macht das System zugänglicher und wartungsfreundlicher.

Eingebaute Zuverlässigkeit: Robuste Fehlerbehandlung, Retry-Logik und Recovery-Mechanismen sind out of the box dabei.

Modularität und Wiederverwendbarkeit: MCP-Server lassen sich projekt- und teamübergreifend einsetzen und fördern so Wiederverwendung und Konsistenz im Code.

Vielfältige Deployment-Optionen: Strands Agents lassen sich auf Lambda, ECS, EKS oder EC2-Instanzen betreiben.

Damit fügt sich der Ansatz nahtlos in moderne cloud-native und Serverless-Designprinzipien ein und setzt auf deklarative Konfiguration, automatische Skalierung und Managed Infrastructure.

Um das Skript mcp_arch_diagram.py auszuführen, müssen Sie die folgenden Python-Pakete installieren:

pip install mcp strands boto3 anthropic

Übersicht der Pakete:

• mcp: Kernimplementierung des Model Context Protocol
• strands: Framework zur Agenten-Orchestrierung
• boto3: AWS SDK für Python (für die Bedrock-Integration erforderlich)
• anthropic: Python-Client-Bibliothek von Anthropic

Weitere Voraussetzungen:

• Stellen Sie sicher, dass uvx global installiert ist, um Pakete dynamisch ausführen zu können.
• Hinterlegen Sie AWS-Credentials für den Bedrock-Zugriff.
• Richten Sie passende IAM-Berechtigungen für die Nutzung von AWS Bedrock ein.

Die Flexibilität von MCP-Servern in Verbindung mit Strands Agents reicht weit über statische Websites hinaus. Hier einige weitere AWS-Architekturen, die sich mit diesem Ansatz erzeugen lassen:

response = agent(
    "Create a diagram for a RESTful API using API Gateway, Lambda functions, and DynamoDB with proper security using IAM roles"
)

Erzeugt ein Diagramm für eine Serverless-API-Architektur mit sauberer Authentifizierung und Datenpersistenz.

response = agent(
    "Design an event-driven pipeline that processes files uploaded to S3, triggers Lambda functions via EventBridge, and stores results in RDS"
)

Hilfreich, um ein Diagramm für skalierbare Datenverarbeitungs-Workflows zu erstellen, die in Echtzeit auf Events reagieren.

response = agent(
    "Create a diagram for a three-tier web application with ALB, EC2 instances in multiple AZs, RDS with read replicas, and ElastiCache"
)

Erzeugt ein Diagramm für klassische mehrschichtige Architekturen mit Hochverfügbarkeit und Performance-Optimierung.

response = agent(
    "Generate a diagram for an ML pipeline using SageMaker for training, Lambda for inference, S3 for data storage, and CloudWatch for monitoring"
)

Erstellt ein Diagramm für End-to-End-Machine-Learning-Workflows mit sauberem Datenmanagement und Monitoring.

Jedes dieser Beispiele zeigt, wie sich natürlichsprachliche Beschreibungen in vollständige AWS-Architekturen übersetzen lassen – ganz ohne komplexen Infrastrukturcode.

Wir haben gesehen, wie sich Architekturdiagramme für einen neuen Workload erstellen lassen – aber wie kommen Sie den Ursachen von Problemen und Ineffizienzen in Ihren bestehenden Workloads auf die Spur? Cloud Diagrams visualisiert Ihren Cloud-Footprint nahezu in Echtzeit, verbindet die einzelnen Services miteinander und liefert konkrete Handlungsempfehlungen. Das senkt Ausfälle, verkürzt Troubleshooting-Aufwände und reduziert die Betriebskosten.