Do conceito ao app de IA: criando assistentes de pesquisa inteligentes com Strands

O problema com o desenvolvimento de IA hoje

Construir um aplicativo de inteligência artificial não deveria exigir um doutorado em aprendizado de máquina nem meses lidando com arquiteturas complexas. Mas é exatamente isso que acontece na prática quando você tenta orquestrar múltiplas chamadas de API, gerenciar o estado de uma conversa e criar agentes capazes de raciocinar de forma autônoma.

Ideias simples de IA acabam se transformando em projetos enormes, que demandam conhecimento especializado em processamento de linguagem natural e sistemas distribuídos. É nesse contexto que a AWS publicou um tutorial mostrando como o Strands Agents muda esse cenário — permitindo construir um assistente de pesquisa completamente funcional com apenas 30 linhas de código.

O que é o Strands Agents?

O Strands Agents é um framework open source que resolve diretamente os desafios do desenvolvimento de IA. Ele oferece uma forma direta de criar agentes inteligentes capazes de realizar tarefas como pesquisa, análise e geração de conteúdo, combinando o poder dos Modelos de Linguagem de Grande Escala (LLMs) com lógica personalizada e APIs via código Python.

A abordagem do framework é orientada pelo modelo: em vez de hardcoding complexo, ele usa LLMs para raciocínio e planejamento autônomos. Isso significa que você pode criar agentes com apenas um prompt e uma lista de ferramentas, enquanto o LLM cuida da lógica e do uso das ferramentas.

Entre os principais diferenciais do Strands Agents estão:

• Arquitetura flexível: suporta desde agentes únicos até redes multi-agente e sistemas hierárquicos.
• Integração via decorator @tool: permite conectar funções externas e APIs de forma simples.
• Design agnóstico de modelo: funciona com diferentes provedores de LLM, incluindo Amazon Bedrock, Anthropic e OpenAI.
• Integração nativa com AWS: conecta-se naturalmente com Amazon Bedrock e AWS Lambda.
• Pronto para produção: equipes da AWS já utilizam o framework em serviços como Amazon Q e AWS Glue.
• Licença Apache 2.0: open source com contribuições ativas da comunidade.
• Respostas em streaming em tempo real: ideal para aplicações interativas que precisam de feedback imediato.

Para um aprofundamento técnico, a AWS disponibilizou o artigo Strands Agents SDK: um mergulho técnico em arquiteturas de agentes e observabilidade.

O papel do Kiro nessa equação

Além do Strands Agents, a AWS apresenta o Kiro, um Ambiente de Desenvolvimento Integrado (IDE) com IA que escreve código para que os desenvolvedores possam focar nas decisões. O Kiro possui um sistema de extensões chamado Kiro Powers, que empacota servidores MCP, arquivos de direcionamento e hooks em unidades reutilizáveis.

O Strands power, por exemplo, reúne busca na documentação do SDK, guias de introdução e padrões corretos de API para que o Kiro possa estruturar agentes com precisão. Com mais de 50 extensões curadas da AWS, parceiros e da comunidade — cobrindo design, implantação, segurança e observabilidade — a instalação é feita com um clique.

Pré-requisitos para começar

Antes de partir para o código, a AWS lista o que você precisa ter configurado:

• Uma conta AWS ativa.
• Usuário configurado no AWS IAM Identity Center ou Builder ID.
• Kiro instalado.
• Credenciais AWS configuradas para acessar o Amazon Bedrock via AWS IAM Identity Center (abordagem recomendada para acesso humano).

Para configurar e fazer login, os comandos são:

aws configure sso
aws sso login --profile research-assistant

Em seguida, é necessário anexar uma política inline de Gerenciamento de Identidade e Acesso (IAM) com escopo reduzido à função ou conjunto de permissões utilizado. Essa política concede apenas as permissões necessárias para o tutorial — invocar o modelo Claude Sonnet via Amazon Bedrock:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:Converse"
      ],
      "Resource": "arn:aws:bedrock:us-west-2::foundation-model/anthropic.claude-3-5-sonnet-20241022-v2:0"
    }
  ]
}

Por fim, adicione o power Build an agent with Strands ao Kiro.

Construindo o assistente de pesquisa

O primeiro agente em minutos

O ponto de partida é instalar o SDK do Strands Agents e o Streamlit no terminal do Kiro:

pip install strands-agents
pip install streamlit

Com isso, já é possível criar o primeiro agente em um arquivo Python chamado research.py:

from strands import Agent

# Create an agent with default settings
agent = Agent()

# Ask the agent a question
agent("Tell me about agentic AI")

Para executá-lo:

python -u research.py

Simples assim. Com essa base estabelecida, o próximo passo é evoluir para uma aplicação web com interface interativa.

Gerando o assistente completo com o Kiro

Aqui entra a vantagem do Kiro: usando linguagem natural, é possível descrever os requisitos e deixar o IDE gerar a implementação. O processo consiste em abrir o Kiro, criar um novo arquivo Python (por exemplo, research_assistant.py) e fornecer o seguinte prompt:

Create a Streamlit research assistant app using strands Agent library with these exact requirements:
1. App title: "Research Assistant" with subtitle "Enter a topic to get research analysis and recommendations"
2. Text input field with placeholder "e.g., renewable energy, artificial intelligence"
3. "Generate Research Report" button that when clicked:
   - Shows spinner with "Researching and analyzing..." message
   - Redirects stdout to prevent terminal output interference (import sys, os and use devnull)
   - Creates Agent() instance
   - Uses this exact prompt template:
     "You are a research assistant. For the topic '{topic}':
     1. Overview of the topic in about 50 words
     2. Find recent 2 articles about {topic} in 20 words each
     3. Things to know relevant to the topic and description as prerequisites in 20 words each
        like if topic is agentic ai then prereq is machine learning and generative ai
     4. 2 key contributors and well known people in this field of research topic including their bio in 25 words each
     5. give relevant 2 urls to read more and any research papers from https://arxiv.org/"
   - Displays response using st.subheader(f"Research Report: {topic}") and st.write(response.message['content'][0]['text'])
   - Restores stdout in finally block
   - Shows warning if no topic entered
Use try/finally pattern for stdout redirection. Keep code minimal and functional.

O código gerado pelo Kiro é o seguinte:

import sys
import os
import streamlit as st
from strands import Agent

st.title("Research Assistant")
st.write("Enter a topic to get research analysis and recommendations")

topic = st.text_input("Research Topic", placeholder="e.g., renewable energy, artificial intelligence")

if st.button("Generate Research Report"):
    if topic:
        with st.spinner("Researching and analyzing..."):
            old_stdout = sys.stdout
            try:
                sys.stdout = open(os.devnull, "w")
                agent = Agent()
                response = agent(
                    f"You are a research assistant. For the topic '{topic}': "
                    f"1. Overview of the topic in about 50 words "
                    f"2. Find recent 2 articles about {topic} in 20 words each "
                    f"3. Things to know relevant to the topic and description as prerequisites in 20 words each "
                    f"like if topic is agentic ai then prereq is machine learning and generative ai "
                    f"4. 2 key contributors and well known people in this field of research topic including their bio in 25 words each "
                    f"5. give relevant 2 urls to read more and any research papers from https://arxiv.org/"
                )
            finally:
                sys.stdout = old_stdout
        st.subheader(f"Research Report: {topic}")
        st.write(response.message["content"][0]["text"])
    else:
        st.warning("Please enter a topic to research.")

Observação importante: sem uma ferramenta de navegação web, o agente gera URLs a partir do seu conhecimento de treinamento. Esses links podem não refletir os artigos mais recentes. Para recuperação em tempo real, é necessário adicionar um servidor MCP apropriado como ferramenta.

Executando a aplicação

No terminal, navegue até o diretório onde o arquivo research_assistant.py foi salvo e execute:

streamlit run research_assistant.py

O Streamlit abrirá a interface no navegador. Basta inserir um tópico de interesse e clicar em “Generate Research Report” para receber o relatório de pesquisa.

Uso responsável de servidores MCP

O tutorial da AWS traz recomendações importantes sobre o uso de servidores MCP:

• Fixe o servidor MCP em uma versão ou hash de commit específico (por exemplo, pip install "arxiv-mcp==X.Y.Z").
• Revise o código-fonte antes de instalar.
• Para casos de uso em produção, a recomendação é usar a recuperação nativa do Amazon Bedrock (Knowledge Bases/RAG).
• Para implantações voltadas ao cliente ou entre organizações, passe servidores MCP de terceiros pelo processo de revisão jurídica e de segurança da sua organização.
• Servidores MCP compartilham os privilégios do processo do agente, incluindo quaisquer credenciais AWS disponíveis. Trate-os como parte do seu perímetro de confiança.
• Para cargas de trabalho em produção, considere os servidores MCP remotos gerenciados pela AWS via Amazon Bedrock AgentCore, que oferecem isolamento de processo, autenticação centralizada e eliminam a exposição local de credenciais.

Considerações de segurança para produção

A AWS reforça que o tutorial é um ponto de partida, e que antes de levar qualquer aplicação baseada nesse padrão para produção, é essencial considerar os seguintes pontos:

• Valide a entrada do usuário: limite o tamanho do tópico e remova caracteres não imprimíveis antes de passar a string para o agente.
• Habilite o Amazon Bedrock Guardrails: anexe um guardrail à chamada do modelo para filtragem de injeção de prompt e saídas inadequadas. Saiba mais em Detectar e filtrar conteúdo prejudicial usando o Amazon Bedrock Guardrails.
• Ative o logging: habilite o registro de invocação de modelos no Amazon Bedrock e os eventos de dados do AWS CloudTrail para bedrock:InvokeModel e bedrock:Converse.
• Controle de custos: configure um alarme de cota sob demanda no Amazon Bedrock e um limite de consultas por sessão para evitar esgotamento de custos.
• Classifique dados persistidos: se armazenar histórico de conversas, classifique os dados e remova valores sensíveis antes de gravar.
• Revise o modelo de responsabilidade compartilhada: consulte o Modelo de Responsabilidade Compartilhada da AWS para entender a divisão entre o que a AWS gerencia e o que é responsabilidade do cliente.

Além disso, o tutorial alerta que o streamlit run vincula ao endereço 127.0.0.1 por padrão, tornando a interface acessível apenas localmente. Não exponha a aplicação à rede local ou à internet sem adicionar autenticação, proteção contra CSRF e um limite de custo no Amazon Bedrock.

Conclusão

O tutorial da AWS demonstra como o Strands Agents, combinado com as capacidades de geração de código do Kiro, permite construir funcionalidades sofisticadas de IA com uma quantidade mínima de código. O framework reduz a complexidade do desenvolvimento de IA por meio de uma criação de agentes intuitiva, enquanto o Kiro aumenta a produtividade do desenvolvedor por meio de codificação assistida por IA.

As aplicações resultantes são ao mesmo tempo poderosas e fáceis de manter, com modificações personalizadas feitas rapidamente via engenharia de prompt. Para quem quer explorar mais sobre o Strands Agents, a AWS disponibilizou o artigo introdutório Apresentando o Strands Agents, um SDK de Agentes de IA Open Source.

Fonte

From idea to AI app: Creating intelligent research assistants with Strands (https://aws.amazon.com/blogs/machine-learning/from-idea-to-ai-app-creating-intelligent-research-assistants-with-strands/)