Aqui está um exemplo de como isso pode ser feito:

# Registro de uma skill
skill_dir = "caminho/para/sua/skill"
toolkit.register_agent_skill(skill_dir)

# Obtendo o prompt da skill do agente
prompt = toolkit.get_agent_skill_prompt()
print(prompt)
 

Exemplo de saída:

# Habilidades do Agente
As habilidades do agente são conjuntos de instruções, scripts e recursos que você pode carregar dinamicamente para melhorar o desempenho em tarefas especializadas. Cada habilidade tem um arquivo `SKILL.md` em sua pasta, que descreve como usar a habilidade. Se quiser usar uma habilidade, DEVE ler cuidadosamente seu arquivo `SKILL.md`.

## assistente-blender
Assistente profissional para processamento de modelos 3D no Blender, fornecendo importação, reparo, dimensionamento e vinculação de ossos. Adequado para desenvolvedores que precisam processar modelos 3D, realizar vinculação de ossos e ajustar dimensionamento.

Consulte "skills\assistente-blender/SKILL.md" para saber como usar esta habilidade.

## assistente-ue-mod
Assistente profissional para criação de mods de jogos UE (Unreal Engine), oferecendo um fluxo de trabalho completo desde a importação de modelos até a construção de MODs. Ideal para desenvolvedores que precisam criar, modificar ou construir MODs de UE.

Consulte "skills\assistente-ue-mod/SKILL.md" para saber como usar esta habilidade.

## assistente-webpage
Assistente profissional para automação e operações em páginas web, fornecendo funcionalidades como abertura de páginas, reconhecimento OCR, cliques e gerenciamento de downloads. Útil para cenários que requerem automação de operações web, extração de dados e gerenciamento de downloads.

Consulte "skills\assistente-webpage/SKILL.md" para saber como usar esta habilidade.
 

Um exemplo de código para inicializar o agente e as ferramentas:

#!/usr/bin/env python3
"""
MCP AI Caller (AgentScope)

Este é o módulo central do sistema, responsável por lidar com a entrada do usuário, invocar ferramentas e gerar respostas. Utiliza o framework AgentScope, que suporta o sistema de habilidades de agentes.
"""

import os
import asyncio
from pathlib import Path
from agentscope.model import OpenAIChatModel, OllamaChatModel
from agentscope.message import Msg, TextBlock
from agentscope import agent, tool, memory, formatter
from agentscope.tool import execute_shell_command, execute_python_code, view_text_file
import agentscope

agentscope.init(studio_url="http://localhost:3000")

# Lista de ferramentas
tools = []

# Carrega ferramentas do diretório
def load_tools_from_directory():
   tools_dir = Path("./ferramentas")
   if not tools_dir.exists():
       print(f"Diretório de ferramentas não existe: {tools_dir}")
       return
   
   # Módulos excluídos
   excluded_modules = ["servidor_blender", "servidor_cad", "servidor_excel", "servidor_ezdxf", "servidor_arquivo", "grounding_dino", "make_exe", "meus_modelos", "ocr", "servidor_pdf", "servidor_solidworks", "servidor_tekla", "servidor_ue"]
   
   # Ferramentas necessárias
   required_tools = {
       "ferramentas_blender": ["ativar_janela_blender", "deletar_todos_os_objetos", "importar_pmx", "reparar_modelo", "definir_escala", "importar_psk", "escalar_para_nome_do_objeto", "definir_osso_pai", "mudar_modo_pose", "adicionar_transferencia_grupo_vertices", "deletar_objeto", "abrir_pasta_blender"],
       "ferramentas_web": ["abrir_pagina_web", "reconhecer_ocr", "clicar_posicao", "rolar_para_baixo", "detectar_yolo", "verificar_barra_de_download"],
       "ferramentas_ue": ["ativar_janela_ue", "importar_fbx", "construir_mod_sifu"]
   }
   
   for subdir in tools_dir.iterdir():
       if subdir.is_dir():
           module_name = subdir.name
           if module_name in excluded_modules:
               print(f"Módulo ignorado: {module_name}")
               continue
           
           if module_name not in required_tools:
               print(f"Módulo ignorado: {module_name} (não está na lista de ferramentas necessárias)")
               continue
           
           for py_file in subdir.glob("*.py"):
               if py_file.name == "__init__.py":
                   continue
               
               try:
                   sys.path.insert(0, str(tools_dir))
                   module = __import__(f"{module_name}.{py_file.stem}")
                   submodule = getattr(module, py_file.stem)
                   
                   for attr_name in dir(submodule):
                       attr = getattr(submodule, attr_name)
                       if callable(attr) and not attr_name.startswith("_") and not isinstance(attr, type) and attr_name in required_tools[module_name]:
                           tool_def = {
                               "name": attr_name,
                               "function": attr,
                               "description": f"Ferramenta do módulo {module_name}.{py_file.stem}"
                           }
                           tools.append(tool_def)
                           print(f"Ferramenta carregada: {attr_name} do {module_name}.{py_file.stem}")
               except Exception as e:
                   print(f"Falha ao carregar módulo de ferramenta {subdir.name}/{py_file.name}: {e}")

# Carrega as ferramentas
load_tools_from_directory()

async def main():
   model_name = "qwen3:4b"
   model = OllamaChatModel(
       model_name=model_name,
       stream=True,
       options={
           "temperature": 0.5,
       },
   )
   
   toolkit = tool.Toolkit()
   toolkit.register_tool_function(execute_shell_command)
   toolkit.register_tool_function(execute_python_code)
   toolkit.register_tool_function(view_text_file)
   
   for tool_def in tools:
       toolkit.register_tool_function(
           tool_func=tool_def["function"],
           func_name=tool_def["name"],
           func_description=tool_def["description"],
       )
       print(f"Ferramenta registrada: {tool_def['name']}")
   
   skills_dir = Path("./habilidades")
   if skills_dir.exists():
       for skill_dir in skills_dir.iterdir():
           if skill_dir.is_dir():
               skill_name = skill_dir.name
               try:
                   toolkit.register_agent_skill(str(skill_dir))
                   print(f"Habilidade registrada: {skill_name}")
               except Exception as e:
                   print(f"Falha ao registrar habilidade {skill_name}: {e}")
   else:
       print(f"Diretório de habilidades não existe: {skills_dir}")
   
   agent_skill_prompt = toolkit.get_agent_skill_prompt()
   print("\nPrompt de habilidades do agente:")
   print(agent_skill_prompt)
   print("\n" + "=" * 80 + "\n")
   
   agent_instance = agent.ReActAgent(
       name="Agente MCP",
       sys_prompt="""Você é um assistente chamado Agente MCP.
# Aviso importante
- Não faça suposições. Todo o conhecimento sobre a biblioteca AgentScope deve vir das habilidades equipadas.
- Quando precisar consultar informações, use as ferramentas fornecidas para ver arquivos relevantes.""",
       model=model,
       formatter=formatter.OllamaChatFormatter(),
       memory=memory.InMemoryMemory(),
       toolkit=toolkit,
   )
   
   print("Digite sua consulta (digite 'exit' para sair):")
   print("Exemplo de consulta: ativar_janela_blender para ativar a janela do Blender")
   
   while True:
       user_input = input("\nDigite sua consulta: ")
       
       if user_input.lower() == 'exit':
           print("Saindo do programa...")
           break
       
       if not user_input.strip():
           print("Por favor, insira uma consulta válida")
           continue
       
       user_msg = Msg(
           name="Usuário",
           content=[TextBlock(text=user_input)],
           role="user",
       )
       
       response = await agent_instance(user_msg)
       print("\nResultado:")
       print(response)
       print("\n" + "=" * 80 + "\n")

if __name__ == '__main__':
   asyncio.run(main())
 

O **AgentScope** é um **framework de desenvolvimento de multi-agentes (Multi-Agent) de código aberto** lançado pelo **Laboratório AliBaba**, focado em construir, implantar e monitorar aplicações de **agentes inteligentes de nível de produção** baseados em grandes modelos de linguagem (LLM). Foi lançado em **2 de setembro de 2025**, versão 1.0, com o objetivo de resolver problemas de **desenvolvimento complexo, colaboração confusa e falta de engenharia** em ambientes empresariais.

Posicionamento Central

"Permitir que os desenvolvedores se concentrem na lógica do negócio, em vez de reinventar a roda"

AgentScope oferece soluções que cobrem todo o ciclo de vida, desde o **desenvolvimento até a implantação, monitoramento e otimização**. É especialmente adequado para cenários complexos que exigem **colaboração de múltiplos agentes, invocação de ferramentas, memória de longo prazo e intervenção em tempo real** (como sistemas de atendimento ao cliente, colaboração de desenvolvimento, assistentes de viagem inteligentes, etc.).

Arquitetura

AgentScope possui uma arquitetura em três camadas, incluindo o **Core (Framework Core)**, **Runtime (Ambiente de Execução)** e **Studio (Plataforma Visual)**. Suporta componentes básicos como mensagens, modelos, memória e feramentas, além de execução segura em containers, monitoramento em tempo real e avaliação de performance.

Características Principais

• Suporte nativo ao paradigma ReAct (Reason & Act)
• Intervenção em tempo real (Realtime Steering)
• Invocação eficiente de ferramentas
• Saída estruturada
• Memória de longo prazo
• Suporte multimodal
• Independência de modelo
• Distribuição e Serverless

Cenários de Aplicação

• Sistemas de atendimento ao cliente
• Assistentes de pesquisa profunda
• Automação de navegadores web
• Planejamento de tarefas complexas
• Geração e revisão de código

Exemplo Rápido (Python)

from agentscope.agent import ReActAgent
from agentscope.model import DashScopeChatModel
from agentscope.tool import Toolkit, execute_python_code
from agentscope.message import Msg
import os

# Inicializa o kit de ferramentas
toolkit = Toolkit()
toolkit.register_tool_function(execute_python_code)

# Cria o agente
agente = ReActAgent(
   name="DevHelper",
   sys_prompt="Você é um assistente de desenvolvimento que pode executar código Python",
   model=DashScopeChatModel(
       model_name="qwen-max",
       api_key=os.getenv("DASHSCOPE_API_KEY")
   ),
   toolkit=toolkit
)

# Envia a tarefa
resposta = await agente(Msg("user", "Imprima 'Olá, AgentScope!' em Python"))
print(resposta.content)
 

AgentScope é mais do que uma simples encapsulação de chamadas LLM; ele fornece infraestrutura de nível de produção para sistemas de multi-agentes complexos, confiáveis e manuteníveis.