Creación de un marketplace de plugins para agentes
Catálogo centralizado de herramientas: publicación, valoración y distribución de plugins para agentes.
Creación de un marketplace de plugins para agentes es una lección gratuita de AI Agents en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Agents, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Agents incluye 4 lecciones en total.
¿Qué es un marketplace de plugins para agentes?
Un marketplace de plugins es un registro centralizado donde los desarrolladores publican herramientas que se pueden compartir, otros desarrolladores las descubren mediante búsquedas y los sistemas de agentes las instalan automáticamente. Piense en npm para herramientas de agentes: publique una vez y utilícela en cualquier lugar.
Arquitectura del marketplace
El marketplace tiene cuatro servicios principales: Registro (almacena los metadatos de los plugins en una base de datos), Almacenamiento (almacena los archivos de los plugins en un almacenamiento de objetos), Búsqueda (índice de texto completo) y Seguridad (firma y verifica los paquetes). Todos se exponen mediante una API REST.
# Marketplace REST API endpoints:
API_ROUTES = {
'POST /plugins': 'Publish a new plugin version',
'GET /plugins': 'List all plugins (paginated)',
'GET /plugins/search?q=weather': 'Search by keyword',
'GET /plugins/{name}': 'Get plugin metadata',
'GET /plugins/{name}/{version}': 'Get specific version metadata',
'GET /plugins/{name}/{version}/download': 'Download plugin archive',
'POST /plugins/{name}/{version}/reviews': 'Submit a rating/review',
'GET /plugins/{name}/reviews': 'Get all reviews',
'DELETE /plugins/{name}/{version}': 'Yank (hide) a version',
}
for route, description in API_ROUTES.items():
print(f'{route}: {description}')Publicación de un plugin
El endpoint de publicación valida el archivo del plugin, comprueba el manifiesto, verifica la identidad del editor (mediante una clave de API), busca patrones maliciosos conocidos, firma el paquete y lo almacena. La publicación es atómica: o la carga completa se realiza correctamente o no se almacena nada.
import hashlib
import hmac
import os
def publish_plugin(
archive_path: str,
api_key: str,
registry_url: str = 'https://registry.agenttools.io'
) -> dict:
import requests
# Compute checksum for integrity
with open(archive_path, 'rb') as f:
data = f.read()
sha256 = hashlib.sha256(data).hexdigest()
# Sign the archive with the developer's API key
signature = hmac.new(
api_key.encode(), data, hashlib.sha256
).hexdigest()
response = requests.post(
f'{registry_url}/plugins',
files={'archive': (os.path.basename(archive_path), data, 'application/zip')},
headers={
'X-API-Key': api_key,
'X-Signature': signature,
'X-Checksum-SHA256': sha256
},
timeout=60
)
response.raise_for_status()
return response.json()Validación en el servidor durante la publicación
El servidor del registro valida cada envío: el manifiesto se puede analizar y está completo, la versión no existe ya, el archivo no supera el límite de tamaño y el análisis de seguridad básico es satisfactorio. El servidor solo acepta la carga después de superar todas las comprobaciones.
import zipfile
import io
import json
MAX_ARCHIVE_SIZE_MB = 50
def validate_plugin_archive(archive_bytes: bytes) -> dict:
errors = []
# Size check
size_mb = len(archive_bytes) / 1024 / 1024
if size_mb > MAX_ARCHIVE_SIZE_MB:
errors.append(f'Archive too large: {size_mb:.1f}MB (max {MAX_ARCHIVE_SIZE_MB}MB)')
return {'valid': False, 'errors': errors}
# Must be a valid zip
try:
zf = zipfile.ZipFile(io.BytesIO(archive_bytes))
except zipfile.BadZipFile:
errors.append('Not a valid zip archive')
return {'valid': False, 'errors': errors}
file_list = zf.namelist()
# Must contain plugin.json
if 'plugin.json' not in file_list:
errors.append('Missing plugin.json in archive root')
# Basic security scan: no .pyc files, no hidden dirs
suspicious = [f for f in file_list if f.startswith('.') or '__pycache__' in f]
if suspicious:
errors.append(f'Suspicious files: {suspicious[:3]}')
return {'valid': len(errors) == 0, 'errors': errors, 'files': len(file_list)}
if __name__ == '__main__':
buf = io.BytesIO()
with zipfile.ZipFile(buf, 'w') as zf:
zf.writestr('plugin.json', '{"name": "demo-plugin"}')
archive_bytes = buf.getvalue()
print('Validation result:', validate_plugin_archive(archive_bytes))
Firma y verificación de paquetes
Firme cada paquete publicado con la clave del editor. Los clientes verifican la firma antes de instalarlo para garantizar que el paquete no haya sido manipulado durante la transferencia o mientras estaba almacenado.
import hashlib
import hmac
def sign_package(archive_bytes: bytes, secret_key: str) -> str:
return hmac.new(
secret_key.encode(), archive_bytes, hashlib.sha256
).hexdigest()
def verify_package(
archive_bytes: bytes,
signature: str,
secret_key: str
) -> bool:
expected = sign_package(archive_bytes, secret_key)
return hmac.compare_digest(expected, signature)
# Example:
package_data = b'fake plugin archive bytes'
developer_key = 'developer_secret_key_abc123'
sig = sign_package(package_data, developer_key)
print(f'Signature: {sig[:20]}...')
# Verify (registry or installer):
valid = verify_package(package_data, sig, developer_key)
print(f'Signature valid: {valid}')
# Tampered data:
tampered = b'tampered bytes'
print(f'Tampered valid: {verify_package(tampered, sig, developer_key)}')Descubrimiento de plugins mediante búsquedas
La API de búsqueda acepta consultas de texto libre y filtros por etiquetas. Devuelve resultados ordenados mediante una puntuación ponderada: la coincidencia exacta con el nombre obtiene la mayor posición, seguida de las coincidencias con etiquetas y, después, de las coincidencias de palabras clave en la descripción.
import requests
def search_marketplace(
query: str,
tags: list = None,
page: int = 0,
per_page: int = 20,
registry_url: str = 'https://registry.agenttools.io'
) -> dict:
params = {
'q': query,
'page': page,
'per_page': per_page
}
if tags:
params['tags'] = ','.join(tags)
response = requests.get(
f'{registry_url}/plugins/search',
params=params,
timeout=10
)
response.raise_for_status()
return response.json()
# Usage:
results = search_marketplace('weather forecast', tags=['iot', 'weather'])
# {
# 'total': 12,
# 'results': [
# {'name': 'weather-tools', 'version': '2.1.0', 'score': 0.98, ...},
# ...
# ]
# }
print(f'Total results: {results.get("total", 0)}')Instalación de un plugin
El proceso de instalación consta de los siguientes pasos: descargar el archivo, verificar la firma, extraerlo en el directorio de plugins, validar el manifiesto, comprobar las dependencias y registrarlo en el registro local de herramientas. Todos los pasos deben completarse correctamente o la instalación se revierte.
import requests
import zipfile
import io
import shutil
import os
def install_plugin(
plugin_name: str,
version: str = 'latest',
plugins_dir: str = 'plugins',
registry_url: str = 'https://registry.agenttools.io'
) -> bool:
# Step 1: Get metadata including expected signature
meta = requests.get(
f'{registry_url}/plugins/{plugin_name}/{version}',
timeout=10
).json()
# Step 2: Download archive
archive_resp = requests.get(
meta['download_url'], timeout=60
)
archive_bytes = archive_resp.content
# Step 3: Verify signature
if not verify_package(archive_bytes, meta['signature'], meta['public_key']):
print('Signature verification FAILED — aborting install')
return False
# Step 4: Extract
install_path = os.path.join(plugins_dir, plugin_name)
if os.path.exists(install_path):
shutil.rmtree(install_path) # remove old version
with zipfile.ZipFile(io.BytesIO(archive_bytes)) as zf:
zf.extractall(install_path)
print(f'Installed {plugin_name} v{version} to {install_path}')
return TrueSistema de valoraciones y reseñas
Un sistema de valoraciones ayuda a los desarrolladores a elegir plugins de alta calidad. Implemente valoraciones de 1 a 5 estrellas con reseñas de texto opcionales. Los datos agregados de las valoraciones (media y cantidad) se almacenan en el registro y se devuelven en los resultados de búsqueda.
import requests
def submit_review(
plugin_name: str,
stars: int,
review_text: str = '',
api_key: str = '',
registry_url: str = 'https://registry.agenttools.io'
) -> dict:
if not 1 <= stars <= 5:
raise ValueError('Stars must be 1-5')
payload = {
'stars': stars,
'review': review_text[:500] # truncate to max length
}
response = requests.post(
f'{registry_url}/plugins/{plugin_name}/reviews',
json=payload,
headers={'X-API-Key': api_key},
timeout=10
)
response.raise_for_status()
return response.json()
def get_reviews(plugin_name: str, registry_url: str = 'https://registry.agenttools.io') -> dict:
response = requests.get(
f'{registry_url}/plugins/{plugin_name}/reviews',
timeout=10
)
return response.json()
# Example response structure:
# {'average_stars': 4.3, 'total_reviews': 47,
# 'reviews': [{'stars': 5, 'review': 'Works great!', 'date': '...'}]}
print('Review system ready')Retirar (deprecando) una versión
Si una versión publicada tiene un error crítico o una vulnerabilidad de seguridad, retírela: márquela como oculta en el registro para que las nuevas instalaciones no puedan utilizarla, pero permita que las instalaciones existentes sigan funcionando. Esto es más seguro que eliminarla, ya que la eliminación interrumpiría los agentes existentes.
import requests
def yank_version(
plugin_name: str,
version: str,
reason: str,
api_key: str,
registry_url: str = 'https://registry.agenttools.io'
) -> dict:
response = requests.delete(
f'{registry_url}/plugins/{plugin_name}/{version}',
json={'reason': reason},
headers={'X-API-Key': api_key},
timeout=10
)
response.raise_for_status()
return response.json()
# Yanked versions:
# - Still downloadable by users who have them pinned
# - Not returned in 'latest' queries
# - Search results show a 'yanked' badge with reason
# - Install of yanked version requires explicit --allow-yanked flag
print('Yanking removes a version from new installs without breaking existing ones.')
print('Always provide a reason: "Security vulnerability in API key handling"')Herramienta CLI del marketplace
Una interfaz de línea de comandos facilita el uso del marketplace desde el terminal o las canalizaciones de CI. Implemente los comandos marketplace install, marketplace search, marketplace publish y marketplace list.
import argparse
import sys
def main():
parser = argparse.ArgumentParser(description='Agent Tool Marketplace CLI')
subparsers = parser.add_subparsers(dest='command')
# Search
search_parser = subparsers.add_parser('search', help='Search plugins')
search_parser.add_argument('query', help='Search query')
search_parser.add_argument('--tag', action='append', dest='tags')
# Install
install_parser = subparsers.add_parser('install', help='Install a plugin')
install_parser.add_argument('plugin', help='Plugin name')
install_parser.add_argument('--version', default='latest')
install_parser.add_argument('--plugins-dir', default='plugins')
# Publish
publish_parser = subparsers.add_parser('publish', help='Publish plugin')
publish_parser.add_argument('archive', help='Path to .zip archive')
publish_parser.add_argument('--api-key', required=True)
args = parser.parse_args()
if args.command == 'search':
results = search_marketplace(args.query, tags=args.tags or [])
for r in results.get('results', []):
print(f'{r["name"]} v{r["version"]} ({r.get("average_stars", "?")} stars)')
elif args.command == 'install':
install_plugin(args.plugin, args.version, args.plugins_dir)
elif args.command == 'publish':
result = publish_plugin(args.archive, args.api_key)
print('Published:', result)Gobernanza del marketplace
Un marketplace público necesita reglas de gobernanza: asignación de nombres (para evitar la apropiación de nombres), moderación de contenido (sin código malicioso), análisis de seguridad (análisis estático durante la carga) y un proceso de retirada (para incidentes legales o de seguridad). Estas son cuestiones tanto organizativas como técnicas.
MARKETPLACE_POLICIES = {
'namespace_policy': (
'Plugin names must be unique across the registry. '
'Names are claimed on first publish. '
'Transfers require proof of original authorship.'
),
'security_scanning': (
'All uploads are scanned with bandit (Python security linter). '
'Critical vulnerabilities block publish. '
'High vulnerabilities generate a warning visible to installers.'
),
'rate_limits': {
'publish_per_hour': 10,
'search_per_minute': 60,
'install_per_minute': 30
},
'takedown_process': (
'Maintainers can yank versions at any time. '
'Legal/security takedowns processed within 48 hours. '
'Appeals via security@agenttools.io'
)
}
for policy, detail in MARKETPLACE_POLICIES.items():
if isinstance(detail, str):
print(f'{policy}: {detail[:80]}...')
else:
print(f'{policy}: {detail}')Comprobación de conocimientos
¿Cuál es la diferencia entre retirar una versión de un plugin y eliminarla?
Resumen: creación de un marketplace de plugins para agentes
¡Enhorabuena por completar esta lección! Estos son los puntos clave:
- Proceso de publicación: validar el archivo → verificar la firma → analizar → almacenar e indexar
- Firma de paquetes: la firma HMAC garantiza la integridad; los clientes la verifican antes de instalar
- Búsqueda: búsqueda de texto completo con filtrado por etiquetas y ordenación por relevancia
- Instalación: descargar → verificar → extraer → validar → registrar (revertir si falla)
- Valoraciones: de 1 a 5 estrellas y reseñas de texto agregadas en el registro
- Retirada: ocultar de las nuevas instalaciones sin interrumpir las existentes
Curso final: El camino hacia los sistemas autónomos.
Preguntas frecuentes
¿La lección «Creación de un marketplace de plugins para agentes» es gratis?
Sí — el texto completo de «Creación de un marketplace de plugins para agentes» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Agents, actualiza a CoddyKit PRO. El curso de AI Agents incluye 4 lecciones en total.
¿Qué aprenderé en «Creación de un marketplace de plugins para agentes»?
Catálogo centralizado de herramientas: publicación, valoración y distribución de plugins para agentes. Practicas AI Agents con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar AI Agents?
No se requiere experiencia previa. AI Agents en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Creación de un marketplace de plugins para agentes»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de AI Agents?
Sí. Cada lección de AI Agents incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Diseño de herramientas de agentes reutilizables
- Descubrimiento y registro de plugins
- Versionado y compatibilidad de herramientas
- Creación de un marketplace de plugins para agentes