Using MCPify for Workflow Automation and RPA Enhancements

TL;DR: Traditional RPA is brittle when inputs are messy or decisions depend on context. Pairing GPT‑5 with MCPify lets your automations understand unstructured inputs (like emails), select the right APIs, and execute multi‑step actions with full transparency. This guide walks through an email‑to‑action workflow where an LLM reads a customer email, calls several APIs via MCPify (CRM, ticketing, product info), decides next steps, updates a ticket, and drafts a reply.

• Who it's for: Automation engineers, RPA teams, and ops pros searching "use GPT‑5 for RPA" or "AI workflow automation example."
• What you'll get: A reference architecture, end‑to‑end Python example, and a quick capabilities table for planning production rollouts.

---

Why add AI to RPA now

RPA excels at structured, repetitive tasks. It struggles when formats vary, inputs are ambiguous, or decisions require judgment. GPT‑5 closes that gap:

• Understands free text across emails, tickets, and docs.
• Plans multi‑step processes and chains tool calls in sequence or parallel.
• Handles API errors gracefully and adapts as schemas evolve.
• Summarizes, validates, and explains results before acting.

Key idea: Let the LLM be the brains and your scripts be the muscle. Give the model transparent, predictable tools it can call on demand.

---

Quick primer: Model Context Protocol (MCP)

MCP is an open standard that defines how AI applications discover and call external tools and data sources. In practice:

• MCP servers expose tools (APIs, databases, file systems).
• MCP clients (LLM apps, agent runtimes) discover these tools and invoke them with structured parameters.
• Tools ship with schemas, examples, and metadata so models know what to call and how to call it.

Useful intros: modelcontextprotocol GitHub, Anthropic's MCP announcement, and modelcontextprotocol.io.

---

Meet MCPify: turn any API into AI‑ready tools

MCPify is the fastest path from "we have APIs" to "our APIs are usable by GPT‑5 and agentic workflows." Point MCPify at REST, GraphQL, or proprietary endpoints (SOAP services via a WSDL→OpenAPI conversion step) and it generates an MCP service with:

• Perfect tool descriptions: parameters, response shapes, examples, rate limits, costs, latency, and token footprint.
• Fine‑grained JSON navigation: JSONPath queries, array slicing, and field extraction.
• Explicit pagination control: page size, page token, and iteration strategies exposed to the model.
• Batch operations: execute multiple calls in parallel to reduce round trips.
• Stateful memory: scratchpad tools to store and reuse intermediate results.
• Cache and rate‑limit transparency: know what's cached, how fresh it is, and when to throttle.
• Monitoring and analytics: end‑to‑end visibility and guardrails for ops and governance.

Explore more: Docs Home, Getting Started. When you're ready, talk to us about your API.

---

Reference architecture: Email to action (RPA + GPT‑5 + MCPify)

Scenario: A customer emails support about a delayed order. Your automation must parse the email, verify the customer, check order and inventory, decide a remedy, update the ticket, and draft a reply.

High‑level flow

1. Ingest: Read email body and metadata.
2. Understand: GPT‑5 extracts intent and entities (customer, orderId, product).
3. Plan: GPT‑5 decides which tools to call and in what order.
4. Fetch: Call CRM, orders, and inventory services (via MCPify).
5. Decide: If backorder, propose upgrade/refund; else trigger expedited shipping.
6. Act: Update the ticket, create a follow‑up task, draft a customer email.
7. Confirm: Return a final summary for auto‑send or human approval.

MCPify services used (examples)

• crm (customer profile and status)
• orders (order and shipment details)
• inventory (stock levels and ETAs)
• tickets (support updates and macros)
• notifications (email templates and send)

---

Tutorial: build the loop in Python

Below is a minimal agent loop. The LLM plans and decides; your script executes MCPify calls and feeds results back.

MCPify serves each wrapped API as an MCP service at https://{service}.mcp.mcpify.org/mcp; in production you would connect an MCP client (for example, the official MCP SDK) to those services and let the model call the generated tools directly. To keep this tutorial focused on the agent loop, the example routes tool calls through a small in-house HTTP bridge (gateway.example.com below) that forwards them to your MCP services. Map service + operationId to your MCPified endpoints; you can keep everything behind one generic executor or expose multiple named tools (one per service).

1) Environment and helpers

import os, requests, json, time
from openai import OpenAI

OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
GATEWAY_API_KEY = os.environ["GATEWAY_API_KEY"]
GATEWAY_URL = os.environ.get("GATEWAY_URL", "https://gateway.example.com/v1")

client = OpenAI(api_key=OPENAI_API_KEY)

def call_mcpify(service: str, operation_id: str, params: dict, *, batch: list | None = None):
    """Generic executor: forwards a tool call (or batch) to your bridge."""
    url = f"{GATEWAY_URL}/tools/execute"
    payload = {"service": service, "operationId": operation_id, "params": params}
    if batch:
        payload = {"batch": batch}  # each: {service, operationId, params}
    headers = {"Authorization": f"Bearer {GATEWAY_API_KEY}", "Content-Type": "application/json"}
    r = requests.post(url, headers=headers, data=json.dumps(payload), timeout=60)
    r.raise_for_status()
    return r.json()

2) Tools advertised to GPT‑5

Expose a generic executor and specialized helpers for batch and JSON slicing. In production, MCPify auto‑generates tool specs per endpoint with full schemas.

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "mcpify_call",
            "description": "Call any MCPify-exposed API by service + operationId with explicit params.",
            "parameters": {
                "type": "object",
                "properties": {
                    "service": {"type": "string", "description": "MCPify service id, e.g., 'crm'"},
                    "operation_id": {"type": "string", "description": "OpenAPI operationId, e.g., 'getCustomerByEmail'"},
                    "params": {"type": "object", "description": "JSON payload or query params"}
                },
                "required": ["service", "operation_id", "params"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "mcpify_batch",
            "description": "Execute multiple MCPify calls in parallel.",
            "parameters": {
                "type": "object",
                "properties": {
                    "calls": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "service": {"type": "string"},
                                "operation_id": {"type": "string"},
                                "params": {"type": "object"}
                            },
                            "required": ["service", "operation_id", "params"]
                        }
                    }
                },
                "required": ["calls"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "json_query",
            "description": "Fine-grained JSON navigation using JSONPath (powered by MCPify JSON tools).",
            "parameters": {
                "type": "object",
                "properties": {
                    "json": {"type": "object"},
                    "jsonpath": {"type": "string", "description": "e.g. $.orders[?(@.status=='open')].id"}
                },
                "required": ["json", "jsonpath"]
            }
        }
    }
]

3) A compact agent loop

Ask GPT‑5 to plan step‑by‑step, call tools, and stop when it reaches a final answer for the automation.

def run_email_to_action_flow(email_text: str):
    system = (
        "You are an automation orchestrator. "
        "Goal: read a support email, decide required checks, call MCPify tools, "
        "and produce: {ticket_update, customer_email_draft, audit_log}.\n"
        "Constraints: obey rate limits, use pagination if needed, prefer batch calls, "
        "minimize tokens. Use json_query to slice large responses."
    )

    messages = [
        {"role": "system", "content": system},
        {"role": "user", "content": f"Customer email:\n---\n{email_text}\n---\n"}
    ]

    while True:
        resp = client.chat.completions.create(
            model="gpt-5",
            messages=messages,
            tools=TOOLS,
            tool_choice="auto",
            temperature=0.2
        )
        msg = resp.choices[0].message

        # Final answer?
        if not getattr(msg, "tool_calls", None):
            return msg.content

        # Execute tool calls
        tool_results = []
        for call in msg.tool_calls:
            name = call.function.name
            args = json.loads(call.function.arguments or "{}")

            try:
                if name == "mcpify_call":
                    result = call_mcpify(args["service"], args["operation_id"], args["params"])
                elif name == "mcpify_batch":
                    result = call_mcpify(service="", operation_id="", params={}, batch=args["calls"])
                elif name == "json_query":
                    url = f"{GATEWAY_URL}/tools/json/query"
                    headers = {"Authorization": f"Bearer {GATEWAY_API_KEY}", "Content-Type": "application/json"}
                    r = requests.post(url, headers=headers, data=json.dumps(args), timeout=30)
                    r.raise_for_status()
                    result = r.json()
                else:
                    result = {"error": f"Unknown tool {name}"}
            except Exception as e:
                result = {"error": str(e)}

            tool_results.append({"tool_call_id": call.id, "name": name, "result": result})

        # Return tool outputs so GPT-5 can continue reasoning
        for tr in tool_results:
            messages.append({
                "role": "tool",
                "tool_call_id": tr["tool_call_id"],
                "name": tr["name"],
                "content": json.dumps(tr["result"])
            })

        time.sleep(0.1)  # optional throttle

4) Prompting GPT‑5 to plan and paginate

Encourage the model to think in Plan → Actions → Results → Decision → Output form, with explicit pagination and caching.

PLANNING_HINTS = """
- Plan the minimal set of calls you need (batch where possible).
- Use explicit pagination: set page_size and track next_page_token.
- For large JSON, call json_query to extract only the fields you need.
- Cache-awareness: if data is fresh per MCPify metadata, reuse it.
- Produce a final JSON with {ticket_update, customer_email_draft, audit_log}.
"""

sample_email = """
Hi team, this is Jamie at Acme. Order #84721 was due yesterday but the portal shows 'awaiting stock'.
Can you confirm ETA or upgrade shipping? This is urgent for our client demo Friday.
"""

final = run_email_to_action_flow(sample_email + "\n" + PLANNING_HINTS)
print(final)

What you'll see

• The model typically calls crm.getCustomerByEmail, orders.getOrderById, and inventory.getSku (often in a single mcpify_batch).
• If orders.getOrderById returns a long history, it calls json_query to extract just the fields it needs (status, shipBy, tracking).
• If multiple pages are needed, it iterates with page_token until complete. See Docs: Pagination and Streaming.
• It decides a remedy (expedite or alternative SKU), updates the ticket via tickets.update, and drafts a reply via notifications.sendEmail.

---

Production tips

• Schema‑first: Rich OpenAPI/GraphQL types are what give the model enough to construct a valid call without trial‑and‑error. MCPify exposes them to the model.
• Guardrails: Use MCPify's rate limit and cost metadata to guide the model (for example, "prefer batch under high load").
• Stateful context: Keep intermediate results in MCPify's scratchpad to avoid re‑fetching. See Docs: Stateful Operations.
• Human‑in‑the‑loop: For sensitive actions (refunds, cancellations), require approval. The loop above can return a summary for review.
• Observability: Use MCPify analytics to trace tool chains, latency, and token use across flows.
• Platform pairing: This approach complements UiPath, Power Automate, Zapier, Make, n8n, and homegrown schedulers. Let those handle triggers and governance; let GPT‑5 + MCPify handle reasoning and tool use.

---

Summary table: MCPify capabilities for RPA

---

Where to go next

• Read the MCPify Getting Started guide: Getting Started
• See JSON tools, pagination, and batch in action: JSON Tools, Pagination and Streaming, Batch Operations
• Learn more about MCP: modelcontextprotocol GitHub, MCP example servers
• Quickstart with GPT‑5: Connect GPT‑5 to your internal API

---

Call to action

Ready to give your bots real decision‑making power? Talk to sales and ship your first email‑to‑action workflow.

• Get in touch: Talk to sales
• Compare plans: Pricing
• Talk to us: Contact the team

---

Sources

• MCPify Home: mcpify.org
• MCPify Docs: /docs
• MCPify Getting Started: /docs/getting-started
• MCPify JSON Tools: /docs/json-tools
• MCPify Pagination and Streaming: /docs/pagination-and-streaming
• MCPify Batch Operations: /docs/batch-operations
• MCPify Stateful Operations: /docs/stateful-operations
• Model Context Protocol GitHub (official): https://github.com/modelcontextprotocol
• Anthropic: Introducing the Model Context Protocol: https://www.anthropic.com/news/model-context-protocol
• Model Context Protocol ‑ Introduction: https://modelcontextprotocol.io/
• Model Context Protocol ‑ Example Servers: https://modelcontextprotocol.io/examples
• Model Context Protocol ‑ Quickstart Server: https://modelcontextprotocol.io/quickstart/server
• GitHub Docs: About Model Context Protocol (MCP): https://docs.github.com/en/copilot/concepts/about-mcp
• GitHub Docs: Extending Copilot Chat with MCP: https://docs.github.com/copilot/customizing-copilot/using-model-context-protocol/extending-copilot-chat-with-mcp
• JSONPath ‑ XPath for JSON (Goessner): https://goessner.net/articles/JsonPath/
• Automation Anywhere: Intelligent Automation vs RPA: https://www.automationanywhere.com/rpa/intelligent-automation-vs-rpa