Anuncios Agentic

Google AdSense para agentes de IA. Agrega 3 líneas de código a tu servidor MCP. Gana el 70% de cada clic en anuncio.

Demo en Vivo · Inicio Rápido · Herramientas MCP · Auto-Alojamiento

Inicio Rápido

Paso 1 — Regístrate y obtén tu clave API (30 segundos):

Visita el formulario web: https://agentic-ads-production.up.railway.app/dev/register

O usa la API directamente:

curl -X POST https://agentic-ads-production.up.railway.app/api/register \
  -H "Content-Type: application/json" \
  -d '{"name": "My MCP Bot", "email": "me@example.com", "project_description": "A coding assistant that recommends dev tools"}'
# Returns: { "api_key": "aa_dev_...", "mcp_url": "https://agentic-ads-production.up.railway.app/mcp" }

Paso 2 — Añade a la configuración de tu cliente MCP:

{
  "mcpServers": {
    "agentic-ads": {
      "url": "https://agentic-ads-production.up.railway.app/mcp",
      "transport": "http"
    }
  }
}

Paso 3 — Llama a search_ads en tu agente y gana con cada clic:

// In your agent logic — when context is relevant
const ads = await mcp.callTool({
  name: 'search_ads',
  arguments: { query: 'best running shoes for marathon', max_results: 1 }
});

// Report events to get paid
await mcp.callTool({
  name: 'report_event',
  arguments: { ad_id: ads[0].ad_id, event_type: 'impression' }
});
// User clicks → report 'click' → you earn $0.35 on a $0.50 CPC ad

Eso es todo. Ya estás monetizando.

Related MCP server: AdKit MCP Server

Por Qué Existe Esto

Has creado un servidor MCP increíble. Los usuarios lo aman. Pero no estás generando dinero.

agentic-ads es la capa de monetización que faltaba en el ecosistema MCP. Es como Google AdSense, pero para agentes de IA en lugar de sitios web.

El Problema

• Existen más de 16,000 servidores MCP. Casi ninguno monetiza.

• Los desarrolladores pasan semanas construyendo herramientas útiles, ganan $0.

• Los usuarios piden recomendaciones de productos a los agentes → los agentes raspan la web → las marcas no pueden alcanzarlos.

La Solución

Anuncios contextuales que respetan la privacidad y se sirven a través de herramientas MCP. Los desarrolladores ganan 70% de participación en ingresos (líder en la industria). Los anunciantes llegan a los usuarios de agentes de IA. Todos ganan.

Calculadora de Ingresos

Ejemplo: Tu servidor MCP recibe 10,000 consultas/mes donde los anuncios tienen sentido.

Con 100k consultas/mes y 5% CTR: $1,750/mes de ingresos pasivos.

Eso son $21,000/año por agregar 3 líneas de código a tu servidor MCP.

Guía de Integración Detallada

Para Desarrolladores MCP (Gana Dinero)

Conecta el servidor en vivo y comienza a llamar a las herramientas — sin proceso de aprobación, sin mínimos.

// 1. When user asks about products/services
const ads = await mcp.callTool({
  name: 'search_ads',
  arguments: {
    query: 'best running shoes for marathon',
    max_results: 2
  }
});

// 2. Show relevant ad in your response (if it adds value)
// 3. Report impression
await mcp.callTool({
  name: 'report_event',
  arguments: { ad_id: 'ad_xyz', event_type: 'impression' }
});

// 4. If user clicks → report 'click' event
// You earn $0.35 on a $0.50 CPC click (70% revenue share)

Para Anunciantes (Alcanza a Usuarios de IA)

# Create campaign + ad via MCP tools
mcp.callTool({
  name: 'create_campaign',
  arguments: {
    name: 'Q1 Running Shoes',
    total_budget: 500,
    pricing_model: 'cpc',
    bid_amount: 0.50
  }
});

mcp.callTool({
  name: 'create_ad',
  arguments: {
    campaign_id: 1,
    creative_text: 'Ultraboost 24 — 30% off! Free shipping.',
    link_url: 'https://adidas.com/ultraboost',
    keywords: ['running shoes', 'sneakers', 'marathon'],
    category: 'footwear'
  }
});

# Monitor analytics
mcp.callTool({ name: 'get_campaign_analytics', arguments: { campaign_id: 1 } });

Cómo Funciona

┌─────────────┐                    ┌──────────────────┐                    ┌──────────────┐
│  Advertiser  │────────────────────│  Agentic Ads MCP │────────────────────│  Your MCP     │
│  (Brand/API) │  create_campaign   │     Server       │  search_ads        │  Server       │
│              │  create_ad         │                  │  report_event      │               │
│              │  get_analytics     │  - Matching      │  get_guidelines    │  Shows ads    │
└─────────────┘                    │  - Billing       │                    │  to users     │
                                   │  - Auth & Rate   │                    └──────────────┘
                                   │  - Analytics     │
                                   └──────────────────┘

Flujo de ejemplo:

1. El usuario pregunta a tu agente: "mejores zapatillas para maratón"

2. Tu agente llama a search_ads → obtiene anuncios relevantes clasificados por puja × relevancia

3. El agente muestra el anuncio de forma natural: "Ultraboost 24 — $126 (30% descuento) en Adidas.com (Patrocinado)"

4. El usuario hace clic → reportas el evento click → ganas $0.35 (70% de $0.50 CPC)

Privacidad: Sin seguimiento de usuarios, sin perfiles, sin cookies. Solo coincidencia contextual de palabras clave.

Por Qué los Desarrolladores MCP Aman Esto

1. Participación de Ingresos Líder en la Industria

70% para ti, 30% para la plataforma. Compara:

2. Sin Fricción de Configuración

• Sin contratos, sin mínimos, sin demoras de aprobación

• Regístrate en segundos vía POST /api/register → obtén tu clave API

• Agrega 1 servidor MCP a tu configuración → comienza a ganar en 5 minutos

3. Respetuoso con la Privacidad

• Sin seguimiento ni perfiles de usuarios

• Sin cookies, sin huellas de navegador

• Solo coincidencia contextual de palabras clave (como los primeros Google AdWords)

• La privacidad de tus usuarios se mantiene intacta

4. Tú Controlas Qué Anuncios se Muestran

• El agente decide qué anuncios (si alguno) mostrar

• El contexto completo del usuario se mantiene local (nunca se envía al servidor de anuncios)

• El umbral de relevancia está en tus manos

• Los usuarios pueden optar por no recibir anuncios ("no ads please")

5. Analíticas Transparentes

• Seguimiento de ingresos en tiempo real

• Ve exactamente qué ganaste, cuándo y por qué

• Sin algoritmos de caja negra ni tarifas ocultas

Herramientas MCP (8 en Total)

Para Desarrolladores (Lado del Consumidor) — 3 Herramientas

Para Anunciantes (Lado del Publicador) — 5 Herramientas

Modelos de Precios

Elige cómo quieres pagar (anunciantes) o ganar (desarrolladores):

Controles de presupuesto: Establece presupuesto total + límites diarios. Pausa automática cuando se agota el presupuesto.

Cómo Obtener tu Clave API

Para llamar a report_event o a las herramientas de anunciante, necesitas una clave API.

Opción A — Formulario web (más fácil):

Visita https://agentic-ads-production.up.railway.app/dev/register y completa tus datos. Tu clave API se muestra inmediatamente.

Opción B — API:

curl -X POST https://agentic-ads-production.up.railway.app/api/register \
  -H "Content-Type: application/json" \
  -d '{"name": "My MCP Bot", "email": "me@example.com", "project_description": "A coding assistant"}'

Respuesta:

{
  "developer_id": "...",
  "api_key": "aa_dev_...",
  "mcp_url": "https://agentic-ads-production.up.railway.app/mcp"
}

Usa api_key en el encabezado Authorization: Authorization: Bearer aa_dev_...

Desplegado en Railway con almacenamiento persistente: El servidor en vivo en agentic-ads-production.up.railway.app se ejecuta en Railway con un volumen persistente — los datos se conservan entre despliegues y reinicios. Para auto-alojamiento, usa DATABASE_PATH=/data/ads.db apuntando a un volumen montado.

Instalación

Opción 1: Conectar al Servidor en Vivo (Más Fácil)

Agrega a la configuración de tu cliente MCP (Claude Desktop, Cursor, Windsurf, etc.):

{
  "mcpServers": {
    "agentic-ads": {
      "url": "https://agentic-ads-production.up.railway.app/mcp",
      "transport": "http"
    }
  }
}

Verificación de estado: https://agentic-ads-production.up.railway.app/health

Opción 2: stdio Local (Desarrollo)

npm install -g agentic-ads

# Add to MCP config
{
  "mcpServers": {
    "agentic-ads": {
      "command": "npx",
      "args": ["agentic-ads", "--stdio"]
    }
  }
}

Opción 3: Auto-Alojamiento (Producción)

git clone https://github.com/nicofains1/agentic-ads.git
cd agentic-ads
npm install && npm run build

# Start HTTP server
PORT=19877 npm run start:http

# Or stdio
npm run start:stdio

Banderas:

node dist/server.js --http --port 19877 --db ./ads.db

Variables de Entorno:

PORT=19877                     # HTTP server port (alternative to --port)
DATABASE_PATH=/data/ads.db     # SQLite database path (default: agentic-ads.db)
AGENTIC_ADS_API_KEY=aa_dev_... # Developer API key for stdio mode

Persistencia de BD: Establece DATABASE_PATH a una ruta en un volumen persistente. En la primera ejecución con una BD vacía, las campañas de demostración se siembran automáticamente. Consulta DEPLOY.md para la guía completa de despliegue (se recomienda Railway para almacenamiento persistente gratuito).

Ejemplos de Integración

Claude Desktop

Agrega a ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "agentic-ads": {
      "command": "npx",
      "args": ["agentic-ads", "--stdio"]
    }
  }
}

Cursor / Windsurf

{
  "mcpServers": {
    "agentic-ads": {
      "url": "https://agentic-ads-production.up.railway.app/mcp",
      "transport": "http"
    }
  }
}

Agente TypeScript Personalizado

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';

const transport = new StdioClientTransport({
  command: 'npx',
  args: ['agentic-ads', '--stdio']
});

const client = new Client({ name: 'my-agent', version: '1.0.0' });
await client.connect(transport);

// Search for ads
const result = await client.callTool({
  name: 'search_ads',
  arguments: {
    query: 'best laptops for coding',
    keywords: ['laptop', 'programming'],
    category: 'electronics',
    max_results: 3
  }
});

console.log(result.content[0].text);
// Returns: { "ads": [ { "ad_id": "...", "creative_text": "...", "relevance_score": 0.87 } ] }

Gestión de Sesiones HTTP Streamable

Al llamar al servidor en vivo a través de HTTP, debes gestionar las sesiones MCP manualmente. Aquí hay un ejemplo completo usando fetch sin formato:

const BASE = "https://agentic-ads-production.up.railway.app";
const API_KEY = "aa_dev_..."; // from /api/register

const headers = {
  "Content-Type": "application/json",
  "Accept": "application/json, text/event-stream",
  "Authorization": `Bearer ${API_KEY}`,
};

// 1. Initialize — get a session ID
const initRes = await fetch(`${BASE}/mcp`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    jsonrpc: "2.0", id: 1, method: "initialize",
    params: {
      protocolVersion: "2024-11-05",
      capabilities: {},
      clientInfo: { name: "my-agent", version: "1.0.0" },
    },
  }),
});
const sessionId = initRes.headers.get("mcp-session-id");

// 2. Send initialized notification (required by MCP spec)
await fetch(`${BASE}/mcp`, {
  method: "POST",
  headers: { ...headers, "mcp-session-id": sessionId },
  body: JSON.stringify({
    jsonrpc: "2.0", method: "notifications/initialized", params: {},
  }),
});

// 3. Call tools — pass session ID on every request
const res = await fetch(`${BASE}/mcp`, {
  method: "POST",
  headers: { ...headers, "mcp-session-id": sessionId },
  body: JSON.stringify({
    jsonrpc: "2.0", id: 2, method: "tools/call",
    params: { name: "search_ads", arguments: { query: "running shoes", max_results: 2 } },
  }),
});

// 4. Parse response (SSE format: "event: message\ndata: {...}")
const text = await res.text();
const dataLine = text.split("\n").find((l) => l.startsWith("data:"));
const result = JSON.parse(dataLine.slice(5));
console.log(result.result.content[0].text);

Puntos clave:

• El encabezado mcp-session-id se devuelve en initialize y debe enviarse en todas las solicitudes posteriores

• La autenticación (Authorization: Bearer ...) se establece por sesión: todas las llamadas a herramientas en esa sesión la heredan

• El servidor usa formato SSE (Server-Sent Events) — analiza la línea data: de la respuesta

• Consulta examples/demo-mcp-server para un ejemplo completo funcional

Arquitectura

┌─────────────────────────────────────────────────────────────┐
│  MCP Server (Node.js 22 + TypeScript)                       │
│  ┌───────────────┐  ┌──────────────┐  ┌─────────────────┐  │
│  │ Tool Registry │  │ Auth & Rate  │  │ Matching Engine │  │
│  │ (8 tools)     │  │ Limiting     │  │ (relevance²     │  │
│  │               │  │ (SHA-256)    │  │ × bid × quality)│  │
│  └───────────────┘  └──────────────┘  └─────────────────┘  │
│  ┌───────────────┐  ┌──────────────┐  ┌─────────────────┐  │
│  │ SQLite (WAL)  │  │ Revenue      │  │ Analytics       │  │
│  │ - Campaigns   │  │ Split Engine │  │ (real-time)     │  │
│  │ - Ads         │  │ (70/30)      │  │                 │  │
│  │ - Events      │  │              │  │                 │  │
│  └───────────────┘  └──────────────┘  └─────────────────┘  │
└─────────────────────────────────────────────────────────────┘
          │                                          │
          │                                          │
  Streamable HTTP (remote)                     stdio (local)

Características clave:

• Privacidad: Sin seguimiento de usuarios, solo coincidencia contextual

• Relevancia: score = relevance² × bidFactor × quality_score (la relevancia domina)

• Atomicidad: Inserción de evento + actualización de estadísticas + división de ingresos en una sola transacción SQLite

• Límite de velocidad: Ventana deslizante por clave (60-120 solicitudes/min dependiendo de la herramienta)

• Autenticación: Claves API con hash SHA-256, control de acceso basado en roles

• Pruebas: 270 pruebas en 13 archivos, todas pasando

Demo: Flujo Completo

# Clone repo
git clone https://github.com/nicofains1/agentic-ads.git
cd agentic-ads

# Install + build
npm install && npm run build

# Seed a local DB with demo data (generates real API keys)
tsx scripts/seed.ts --db test.db
# Note: seed.ts prints the generated dev/adv keys — use them below

# Run smoke test with real keys from seed output
tsx scripts/smoke-test.ts --db test.db --dev-key aa_dev_... --adv-key aa_adv_...

Salida:

✅ Created advertiser: Adidas
✅ Created campaign: Q1 Running Shoes ($500 budget, CPC $0.50)
✅ Created ad: "Ultraboost 24 — 30% off!"
✅ Created developer: TestBot
✅ Searched ads for "running shoes" → 1 result (relevance 0.95)
✅ Reported impression → $0.00 charged (CPC model)
✅ Reported click → $0.50 charged, developer earned $0.35
✅ Analytics: 1 impression, 1 click, $0.50 spent, $0.35 developer revenue

Cómo Cobran los Desarrolladores

Cuando tu servidor MCP reporta un evento de clic en un anuncio CPC, el 70% de la puja va para ti — registrado de forma atómica en nuestra base de datos. Una vez que tu saldo alcanza $10, envía un correo a payouts@agentic-ads.com con tu developer_id y tu método de pago preferido (PayPal o USDC en Polygon). Verificamos tu saldo y enviamos el pago dentro de 5 días hábiles. Los pagos automatizados por Stripe están en la hoja de ruta para cuando la red escale.

FAQ

Para Desarrolladores

P: ¿Cómo obtengo una clave API? R: Regístrate a través del endpoint REST:

curl -X POST https://agentic-ads-production.up.railway.app/api/register \
  -H "Content-Type: application/json" \
  -d '{"name": "Your Name", "email": "you@example.com"}'
# Returns: { "developer_id": "...", "api_key": "aa_dev_...", "mcp_url": "..." }

Usa la api_key devuelta como Authorization: Bearer aa_dev_... en tus solicitudes MCP.

P: ¿TENGO que mostrar anuncios? R: No. Tú decides qué anuncios mostrar. Solo muéstralos si realmente añaden valor al usuario. La autonomía del agente es una característica.

P: ¿Qué pasa si mis usuarios odian los anuncios? R: Sigue las pautas de get_ad_guidelines: máximo 1-2 anuncios por respuesta, siempre indica "patrocinado", respeta la opción de exclusión ("no ads please").

P: ¿Esto está listo para producción? R: Sí. 270 pruebas pasando, en vivo en https://agentic-ads-production.up.railway.app, licencia MIT.

P: ¿Qué clientes MCP son compatibles? R: Cualquier cliente MCP que admita stdio o Streamable HTTP. Probado con Claude Desktop, Cursor, Windsurf, agentes personalizados.

Para Anunciantes

P: ¿Cómo creo anuncios? R: Usa las herramientas MCP create_campaign y create_ad con una clave API de anunciante. Consulta smoke-test.ts para ejemplos.

P: ¿Cómo se protege mi presupuesto? R: El seguimiento del presupuesto es atómico (transacción SQLite). Cuando el presupuesto se agota → la campaña se pausa automáticamente. Sin sobregasto.

P: ¿Puedo hacer seguimiento de conversiones? R: Sí, usa el modelo de precios CPA + report_event con event_type: 'conversion'. Agrega parámetros UTM a la URL de tu enlace para atribución.

P: ¿Qué opciones de segmentación existen? R: MVP tiene palabras clave (coincidencia exacta + parcial), categorías, geo (a nivel de país) e idioma. La coincidencia semántica llegará en la Fase 2.

General

P: ¿Rastrean a los usuarios? R: No. Solo recibimos consultas de palabras clave anonimizadas de los agentes. Sin IDs de usuario, sin cookies, sin perfiles. Prioridad a la privacidad.

P: ¿Cómo previenen el fraude? R: MVP utiliza autenticación por clave API + limitación de velocidad + informes basados en confianza. La Fase 2 añade heurísticas de detección de anomalías (consulte issue #47).

P: ¿Esto es código abierto? R: Sí, licencia MIT. Haz un fork, autohospédalo, contribuye.

Hoja de ruta

• MVP — 8 herramientas MCP, coincidencia de palabras clave, facturación, autenticación, 270 pruebas

• Desplegado — En vivo en https://agentic-ads-production.up.railway.app

• Listados en Marketplace — Enviar a Anthropic Registry, Smithery, Glama, PulseMCP (Semana 1)

• API REST del Panel — Interfaz web para anunciantes/desarrolladores (#40)

• Detección de Fraude — Heurísticas de anomalías (#47)

• Coincidencia Semántica — Relevancia basada en embeddings (Fase 2)

• Pruebas A/B — Variantes de creatividades publicitarias (#41)

• Pagos con Stripe — Pagos automáticos a desarrolladores (Fase 3)

Contribuir

Seguimos el flujo de trabajo de GitHub Issues:

1. Comprueba si existe un issue para tu idea

2. Si no: gh issue create --title "Tu idea"

3. Obtén aprobación antes de empezar a trabajar

4. Rama: feature/#N-descripción

5. Commit: feat(#N): descripción

6. PR a main

Consulta CLAUDE.md para obtener directrices detalladas.

Documentación

• CLAUDE.md — Directrices de desarrollo

• bulloak.md — Especificación de comportamiento (fuente de verdad para las pruebas)

• docs/PRD.md — Documento completo de requisitos del producto

• scripts/smoke-test.ts — Implementación de referencia

Soporte

• GitHub Issues: https://github.com/nicofains1/agentic-ads/issues

• Discusiones: (próximamente)

• Discord: (próximamente — únete a la comunidad MCP Developers)

Licencia

MIT — consulta LICENSE para más detalles.

Por Qué Esto Importa

Los agentes de IA se están comiendo la web. Los usuarios preguntan a los agentes en lugar de buscar en Google. Los agentes responden en lugar de los sitios web.

El viejo internet: Los usuarios navegan por sitios web → ven anuncios → los anunciantes llegan a los usuarios.

El nuevo internet: Los usuarios preguntan a los agentes → los agentes raspan sitios web → los anunciantes no pueden llegar a los usuarios.

agentic-ads soluciona esto. Es la capa publicitaria para la economía de los agentes.

Y tú — el desarrollador de MCP — ganas el 70% de los ingresos por ser el intermediario.

La oportunidad: Más de 16.000 servidores MCP, casi ninguno monetiza. Puedes ser el primero.

Construido con Model Context Protocol (MCP) — el estándar abierto para conectar agentes de IA con herramientas.

Demo en vivo: https://agentic-ads-production.up.railway.app

Comienza: Añade el servidor MCP a tu configuración, gana tu primer dólar esta semana.