---
title: "Microsoft Agent Framework"
description: "Crea flujos de trabajo con Microsoft Agent Framework en Python o .NET para búsqueda de tweets, perfiles y escrituras en X revisadas a través de TwexAPI MCP."
---

Crea un agente de Twitter API con Microsoft Agent Framework a través del servidor MCP de TwexAPI. Busca tweets, inspecciona perfiles, lee tendencias y revisa acciones de escritura. Persiste IDs de tweet, cursores y nombres de ruta fuera de la transcripción del chat.

## ¿Por qué usar Microsoft Agent Framework con TwexAPI?

El framework hospeda agentes con llamadas a herramientas en Python o .NET. TwexAPI proporciona `explore` y `twexapi_request` sobre Streamable HTTP.

| Tarea del agente | Ruta de TwexAPI | Conservar para el siguiente paso |
| --- | --- | --- |
| Buscar tweets | `POST /twitter/advanced_search/page` | Consulta, IDs de tweet, autores, `created_at`, cursor |
| Inspeccionar un perfil | `GET /twitter/{screen_name}/about` | ID de usuario, nombre de usuario, biografía, cantidad de seguidores |
| Listar seguidores | `POST /v3/twitter/users/followers` | Nombre de usuario, filas de seguidores, `next_cursor` |
| Publicar o responder | `POST /twitter/tweets/create` | ID de tweet, ruta, aprobación humana, confirmación de cookie |

Usa este framework cuando ya ejecutes hosts de agentes de Microsoft. Usa el [Python SDK](/sdks/python) o el [C# SDK](/sdks/csharp) para trabajos deterministas sin modelo.

## Requisitos previos

- Python 3.10 o posterior, o un host .NET 8+ con soporte MCP Streamable HTTP
- Una [API key de TwexAPI](https://twexapi.io/dashboard)
- Un modelo configurado para el runtime del agente
- Una cookie de Twitter o `auth_token` para acciones de escritura — consulta

Las lecturas públicas de X no requieren credenciales de X Developer. Autentícate con TwexAPI.

## Instalación

Python:

```bash
python -m pip install "agent-framework>=0.2" mcp python-dotenv pydantic
```

```txt .env
TWEXAPI_API_KEY=YOUR_API_KEY
OPENAI_API_KEY=sk-...
```

## Conectar TwexAPI MCP

```python
import os

from agent_framework import MCPStreamableHTTPTool

mcp_tool = MCPStreamableHTTPTool(
    name="twexapi",
    url="https://api.twexapi.io/mcp",
    headers={"x-api-key": os.environ["TWEXAPI_API_KEY"]},
    description="TwexAPI X/Twitter tools through MCP",
)
```

JSON equivalente del host:

```json
{
  "name": "twexapi",
  "transport": "streamable-http",
  "url": "https://api.twexapi.io/mcp",
  "headers": {
    "x-api-key": "YOUR_API_KEY"
  }
}
```

Las solicitudes MCP no autenticadas devuelven `401`.

## Ejemplo completo (Python)

```python
import asyncio
import os
from pathlib import Path
from typing import Literal

from agent_framework import ChatAgent, MCPStreamableHTTPTool
from agent_framework.openai import OpenAIChatClient
from dotenv import load_dotenv
from pydantic import BaseModel


class TweetRow(BaseModel):
    tweet_id: str
    text: str
    author_username: str | None = None
    created_at: str | None = None


class TweetSearchHandoff(BaseModel):
    query: str
    route_used: str
    tweets: list[TweetRow]
    has_more: bool
    next_cursor: str | None = None
    stop_reason: Literal[
        "complete",
        "requested_limit",
        "cursor_stalled",
        "page_cap",
    ]


async def main() -> None:
    load_dotenv()

    mcp_tool = MCPStreamableHTTPTool(
        name="twexapi",
        url="https://api.twexapi.io/mcp",
        headers={"x-api-key": os.environ["TWEXAPI_API_KEY"]},
        description="TwexAPI X/Twitter tools through MCP",
    )

    async with mcp_tool:
        agent = ChatAgent(
            chat_client=OpenAIChatClient(model_id="gpt-4o"),
            name="twexapi_agent",
            instructions=(
                "Use TwexAPI MCP. Call explore before twexapi_request. "
                "Preserve exact IDs and cursors. Never invent missing fields. "
                "Ask for confirmation before read_only: false actions. "
                "Return only JSON for TweetSearchHandoff."
            ),
            tools=[mcp_tool],
        )

        response = await agent.run(
            "Search 25 recent tweets about Microsoft Agent Framework MCP. "
            "Return query, route_used, tweets, has_more, next_cursor, and stop_reason as JSON."
        )

        handoff = TweetSearchHandoff.model_validate_json(response.text)
        Path("twexapi-agent-framework-handoff.json").write_text(
            handoff.model_dump_json(indent=2),
            encoding="utf-8",
        )


asyncio.run(main())
```

Elimina fences de Markdown si el modelo envuelve el JSON. Persiste el archivo fuera del estado de conversación.

## Bosquejo de host .NET

```csharp
var mcp = new McpStreamableHttpTool
{
    Name = "twexapi",
    Url = new Uri("https://api.twexapi.io/mcp"),
    Headers = { ["x-api-key"] = Environment.GetEnvironmentVariable("TWEXAPI_API_KEY")! },
};
```

Usa la misma instrucción: `explore` primero, conserva cursores, detente antes de `read_only: false`. Las llamadas REST tipadas pertenecen al [C# SDK](/sdks/csharp).

## Conservar el contrato de respuesta MCP

Reutiliza la misma consulta y filtros en cada página. Trata cada cursor como opaco.

Detén la paginación cuando se alcance el total solicitado, `has_more` sea false, `next_cursor` se repita o se alcance el límite de páginas.

## Mantener una entrega de agente reanudable

<CardGroup cols={2}>
  <Card title="Páginas de tweets" icon="message-square">
    Almacena `tweet_id`, `text`, `author_username`, `created_at`, `has_more`, `next_cursor` y la consulta original.
  </Card>
  <Card title="Filas de perfil" icon="user-round">
    Almacena `user_id`, `username`, `name`, `description` y cantidades de seguidores.
  </Card>
  <Card title="Páginas de seguidores" icon="users">
    Almacena nombre de usuario de origen, filas de seguidores, `next_cursor` e índice de página.
  </Card>
  <Card title="Acciones de escritura" icon="send">
    Almacena ruta, texto de vista previa y aprobación. Mantén las cookies fuera del archivo de entrega. Consulta.
  </Card>
</CardGroup>

Consulta [Agent MCP Handoff](/mcp/agent-handoff).

## Construir manejo de errores

| Estado | Significado | Decisión del agente |
| --- | --- | --- |
| `400` | Ruta o parámetros inválidos | Corrige la solicitud antes de reintentar |
| `401` | API key faltante o inválida | Detente y reemplaza la credencial |
| `403` | Acceso denegado o créditos | Pausa escrituras; verifica [Get Balance](/api-reference/balance-endpoints/get-balance-api-balance-get) |
| `429` | Límite de tasa alcanzado | Espera y luego reanuda el mismo cursor |
| `5xx` | Fallo temporal del servidor | Aplica backoff acotado a lecturas seguras |

Nunca reintentes una escritura después de un timeout sin una verificación de lectura. Consulta [Error Handling](/guides/error-handling) y [Rate Limits](/guides/rate-limits).

## Requerir aprobación antes de acciones en X

```txt
You have access to TwexAPI MCP tools.
Call explore before twexapi_request.
Use only relative paths returned by explore.
Return tweet_id, user_id, author_username, route_used, has_more, and next_cursor.
Ask for confirmation before read_only: false actions.
Never print cookie or auth_token values.
```

Previsualiza con el [CLI](/sdks/cli) `--dry-run`. Ejecuta escrituras aprobadas a través de REST o un SDK, no un bucle de agente sin supervisión.

## Guía de producción

- Usa una API key por entorno. No incrustes keys en prompts.
- Registra nombres de herramientas MCP y valores de `path` devueltos, no headers de cookie.
- Persiste cursores e IDs de tweet en tu almacén, no solo en la memoria de `ChatAgent`.
- Separa investigación de lectura y ejecución de escritura en agentes o trabajos distintos.

## Versiones de paquetes

| Paquete | Rango compatible |
| --- | --- |
| Python | `>=3.10` |
| `agent-framework` | `>=0.2` |
| `mcp` | `>=1.9` |
| `pydantic` | `>=2.7` |

## Próximos pasos

- [MCP Tools](/mcp/tools)
- [Agent MCP Handoff](/mcp/agent-handoff)
-
- [Python SDK](/sdks/python)
- [C# SDK](/sdks/csharp)
- [Advanced Twitter Search](/api-reference/search-endpoints/get-data-page-twitter-advanced-search-page-post)
