Skip to main content
Glama

create_integration

Set up publishing integrations for content platforms by providing service credentials. Automatically tests connections for WordPress, Webflow, Wix, GoHighLevel, and webhook services.

Instructions

Create a publishing integration. Provide service-specific credentials. A connection test runs automatically after creation. Supported services: wordpress, webflow, wix, gohighlevel, webhook.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
workspace_idYesWorkspace UUID
serviceYesService: wordpress, webflow, wix, gohighlevel, webhook
nameYesIntegration name
auto_publishNoAuto-publish completed articles (default false)
wordpress_urlNo[wordpress] Site URL
wordpress_usernameNo[wordpress] Username
wordpress_application_passwordNo[wordpress] Application password
webflow_api_tokenNo[webflow] API token
webflow_site_idNo[webflow] Site ID
webflow_collection_idNo[webflow] Collection ID
webflow_publication_statusNo[webflow] Publication status: published or draft
wix_api_keyNo[wix] API key
wix_site_idNo[wix] Site ID
wix_member_idNo[wix] Member ID
gohighlevel_api_tokenNo[gohighlevel] API token
gohighlevel_location_idNo[gohighlevel] Location ID
gohighlevel_blog_idNo[gohighlevel] Blog ID
gohighlevel_author_idNo[gohighlevel] Author ID
gohighlevel_category_idNo[gohighlevel] Category ID
gohighlevel_publication_statusNo[gohighlevel] Publication status: PUBLISHED or DRAFT
webhook_urlNo[webhook] URL to receive POST requests
webhook_bearer_tokenNo[webhook] Bearer token for authentication

Implementation Reference

  • The handler logic for 'create_integration' which prepares the integration object and performs a POST request to the integration endpoint.
    async ({ workspace_id, ...params }) => {
      const body: Record<string, unknown> = {
        service: params.service,
        name: params.name,
      };
      if (params.auto_publish !== undefined) body.auto_publish = params.auto_publish;
    
      const serviceFields = [
        'wordpress_url', 'wordpress_username', 'wordpress_application_password',
        'webflow_api_token', 'webflow_site_id', 'webflow_collection_id', 'webflow_publication_status',
        'wix_api_key', 'wix_site_id', 'wix_member_id',
        'gohighlevel_api_token', 'gohighlevel_location_id', 'gohighlevel_blog_id',
        'gohighlevel_author_id', 'gohighlevel_category_id', 'gohighlevel_publication_status',
        'webhook_url', 'webhook_bearer_token',
      ];
      for (const f of serviceFields) {
        const v = (params as Record<string, unknown>)[f];
        if (v !== undefined) body[f] = v;
      }
    
      const res = await client.post(`/workspaces/${workspace_id}/integrations`, { integration: body });
      return { content: [{ type: 'text' as const, text: JSON.stringify(res.data) }] };
    }
  • The Zod schema validation for the 'create_integration' tool parameters.
    {
      workspace_id: z.string().describe('Workspace UUID'),
      service: z.string().describe('Service: wordpress, webflow, wix, gohighlevel, webhook'),
      name: z.string().describe('Integration name'),
      auto_publish: z.boolean().optional().describe('Auto-publish completed articles (default false)'),
      wordpress_url: z.string().optional().describe('[wordpress] Site URL'),
      wordpress_username: z.string().optional().describe('[wordpress] Username'),
      wordpress_application_password: z.string().optional().describe('[wordpress] Application password'),
      webflow_api_token: z.string().optional().describe('[webflow] API token'),
      webflow_site_id: z.string().optional().describe('[webflow] Site ID'),
      webflow_collection_id: z.string().optional().describe('[webflow] Collection ID'),
      webflow_publication_status: z.string().optional().describe('[webflow] Publication status: published or draft'),
      wix_api_key: z.string().optional().describe('[wix] API key'),
      wix_site_id: z.string().optional().describe('[wix] Site ID'),
      wix_member_id: z.string().optional().describe('[wix] Member ID'),
      gohighlevel_api_token: z.string().optional().describe('[gohighlevel] API token'),
      gohighlevel_location_id: z.string().optional().describe('[gohighlevel] Location ID'),
      gohighlevel_blog_id: z.string().optional().describe('[gohighlevel] Blog ID'),
      gohighlevel_author_id: z.string().optional().describe('[gohighlevel] Author ID'),
      gohighlevel_category_id: z.string().optional().describe('[gohighlevel] Category ID'),
      gohighlevel_publication_status: z.string().optional().describe('[gohighlevel] Publication status: PUBLISHED or DRAFT'),
      webhook_url: z.string().optional().describe('[webhook] URL to receive POST requests'),
      webhook_bearer_token: z.string().optional().describe('[webhook] Bearer token for authentication'),
    },
  • The registration of the 'create_integration' tool within the MCP server.
    server.tool(
      'create_integration',
      'Create a publishing integration. Provide service-specific credentials. A connection test runs automatically after creation. Supported services: wordpress, webflow, wix, gohighlevel, webhook.',
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions that 'A connection test runs automatically after creation,' which is valuable behavioral context. However, it doesn't disclose important traits like whether this is a mutating operation (implied but not stated), what permissions are required, error handling, or what happens if the connection test fails. For a creation tool with complex parameters and no annotations, this is insufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise - just two sentences that efficiently convey the core purpose, required inputs (credentials), automatic behavior (connection test), and supported services. Every word earns its place with zero waste or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (22 parameters, creation operation) and absence of both annotations and output schema, the description is incomplete. It doesn't explain what the tool returns, what happens on success/failure, authentication requirements, or error conditions. For a tool that creates integrations with multiple service configurations, more contextual information would be helpful for an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all 22 parameters thoroughly with service-specific groupings. The description adds minimal value beyond the schema by listing the supported services, but doesn't provide additional semantic context about parameter relationships, dependencies, or usage patterns. The baseline of 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool creates a publishing integration and lists supported services, providing a specific verb (create) and resource (publishing integration). However, it doesn't explicitly differentiate from sibling tools like 'update_integration' or 'reconnect_integration' beyond the obvious 'create' vs 'update/reconnect' distinction.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage context by stating 'Provide service-specific credentials' and listing supported services, suggesting this should be used when setting up new publishing integrations. However, it doesn't provide explicit guidance on when to use this vs alternatives like 'update_integration' or 'reconnect_integration', nor does it mention prerequisites or when-not-to-use scenarios.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/hirebalzac/mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server