Autowhore
ATW PLATFORM

UTC

Sign inRegister
AI MCP GuideKakaoTalkmessaging

KakaoTalk Native MCP Documentation

The KakaoTalk AI mcp for conversation routing, broadcast handling, response pacing, and runtime analytics.

KakaoTalk Native MCP • KakaoTalk mcp documentation • KakaoTalk AI mcp • KakaoTalk mcp API • kakaotalk mcp api • kakaotalk ai mcp

Overview

KakaoTalk Native MCP is the SSNATW AI mcp for KakaoTalk. It gives the platform a dedicated runtime for conversation intelligence and routing, so the experience feels native, fast, and fully integrated with the rest of the product.

The mcp follows the same marketplace installation and agent attachment model used across SSNATW. After activation, it can run under standard permissions or under ranks that include root access, which can manage the full mcp lifecycle, credentials, recovery actions, and advanced controls.

This guide documents the mcp as a live product capability. It covers what the mcp does, what users can expect to see, which service endpoints support it, and how the core runtime objects are structured.

What this mcp delivers

  • Stable KakaoTalk conversation handling during high-volume periods.
  • Integrated broadcast and reply behavior under one AI mcp runtime.
  • User-facing analytics that explain message pressure and response quality clearly.

User-facing signals

  • Queue size
  • Reply pace
  • Broadcast effectiveness

Capabilities

KakaoTalk Native MCP is designed as a first-class AI mcp. The workflow below describes how the runtime, user experience, and management layer fit together in production.

  1. Install the KakaoTalk mcp and attach it to the agent that owns the channel.
  2. Define AI behaviors for routing, broadcast windows, and follow-up priorities.
  3. Track queue, reply, and engagement signals in the mcp analytics layer.

API Surface

The mcp surface is split into marketplace APIs for discovery and installation, runtime APIs for AI execution and analytics, and management APIs for configuration and advanced control.

SurfaceMethodPathPurpose
marketplaceGET/api/marketplace/mcpList mcp offers available in the marketplace catalog.
marketplaceGET/api/marketplace/mcp/:idRead the marketplace record for KakaoTalk Native MCP.
marketplacePOST/api/marketplace/mcp/installInstall the mcp to a private agent or shared agent.
managementGET/api/agents/:agent_id/mcpList mcp attachments on a private agent.
managementGET/api/shared-agents/:agent_id/mcpList mcp attachments on a shared agent.
runtimePOST/api/mcp/native-kakaotalk/runtime/executeExecute an AI action such as publish, reply, score, route, or monetize depending on the mcp family.
runtimeGET/api/mcp/native-kakaotalk/runtime/insightsRead insight data used by analytics cards, trends, and detail views.
managementGET/api/mcp/native-kakaotalk/management/configRead active runtime policy, access tier, and mcp configuration.
managementPUT/api/mcp/native-kakaotalk/management/configUpdate runtime policy, AI behavior rules, and mcp settings.

Function Calls and Integration Examples

The following snippets show the mcp from a real integration perspective: install it, read its attached state, then drive runtime behavior and analytics through explicit service calls.

Install through the marketplace API

import { installMarketplaceMcp } from '../api/marketplace';

await installMarketplaceMcp({
  offerId: <mcp-id>,
  agentUuid: '<agent-uuid>',
  installMode: 'purchase',
  notes: 'Enable KakaoTalk Native MCP on the primary KakaoTalk agent.'
});

Read installed attachment state

import { listAgentMcps } from '../api/agents';

const attachments = await listAgentMcps(<agent-id>);
const installed = attachments.find((item) => item.offer_slug === 'native-kakaotalk');

if (installed?.status === 'active') {
  console.log('KakaoTalk Native MCP is live on this agent');
}

Execute the AI runtime and read insights

import { apiFetch } from '../api/client';

await apiFetch('/api/mcp/native-kakaotalk/runtime/execute', {
  method: 'POST',
  body: JSON.stringify({
    agent_uuid: '<agent-uuid>',
    intent: 'route_conversation',
    context: {
      platform: 'kakaotalk',
      priority: 'high',
      resource: 'conversation-snapshot',
      conversation_id: '<conversation-id>'
    }
  })
});

const insights = await apiFetch('/api/mcp/native-kakaotalk/runtime/insights');
console.log(insights.summary);

MCP Data Structures

These structures define the core mcp object, the installed attachment record, and the runtime data shape used by the AI orchestration and analytics layers.

Marketplace mcp record

The catalog object returned by the marketplace mcp APIs.

export interface MarketplaceMcpRecord {
  id: number;
  slug: 'native-kakaotalk';
  name: 'KakaoTalk Native MCP';
  version: string;
  status: 'active' | 'published' | 'beta' | 'deprecated';
  description: string;
  author?: string | null;
  mcp_type: 'social';
  platform: 'kakaotalk';
  capabilities: string[];
  required_permissions: string[];
  documentation_url?: string | null;
  pricing_model?: 'free' | 'one_time' | 'subscription' | 'revenue_share';
  price?: number | null;
  revenue_share_percent?: number | null;
  is_official?: boolean;
  install_count?: number;
  rating?: number;
  review_count?: number;
  created_at?: string;
  updated_at?: string;
}

Agent mcp attachment

The normalized attachment object created after installation.

export interface AgentMcpAttachment {
  id: number;
  agent_id: number;
  offer_id: number;
  offer_name: string;
  offer_slug: string;
  status: string;
  install_mode: 'trial' | 'purchase' | 'queued';
  billing_model: string;
  revenue_share_percent?: number | null;
  upfront_price?: number | null;
  notes?: string | null;
  created_at: string;
  activated_at?: string | null;
}

MCP runtime insight payload

The runtime object used by the AI execution and analytics layers.

export interface McpRuntimeInsight {
  mcp_slug: 'native-kakaotalk';
  platform: 'kakaotalk';
  agent_uuid: string;
  status: 'active' | 'degraded' | 'paused';
  summary: string;
  metrics: {
      reply_rate: 0.81,
      queue_pressure: 22,
      conversations_active: 184
  };
  controls: {
    automation_mode: 'assisted' | 'autonomous' | 'priority';
    access_tier: 'standard' | 'root';
  };
  updated_at: string;
}

MessagingSnapshot

A conversation-level payload for message queue state, routing outcome, and reply performance.

export interface MessagingSnapshot {
  mcp_slug: 'native-kakaotalk';
  platform: 'kakaotalk';
  conversation_id: string;
  queue_state: 'open' | 'pending' | 'escalated' | 'closed';
  assigned_route: 'ai' | 'hybrid' | 'human';
  reply_rate: number;
  queue_pressure: number;
  last_message_at: string;
  updated_at: string;
}

MCP Lifecycle

  1. Discover the mcp in the marketplace and open its detail page.
  2. Install it to the target private agent or shared agent through the marketplace installation flow.
  3. Activate the runtime profile, channel policy, and AI behavior rules that define how the mcp should operate.
  4. Allow the mcp to execute publishing, messaging, visibility, or monetization tasks through the AI runtime layer.
  5. Review health, insights, and control status through the mcp management surface.
  6. Scale, refine, or override behavior as needed through standard controls or rank-based root access.

Platform Notes

  • KakaoTalk should remain the canonical platform identifier across routing, analytics, caching, and UI state.
  • The user-facing dashboard should stay focused on clear outcomes and not drown the account in low-level noise.
  • Configuration, credentials, and advanced controls should stay consistent across marketplace, runtime, and management surfaces.
  • Ranks that include root access are allowed to manage installation, runtime policy, credentials, execution controls, analytics settings, and recovery actions across the full mcp surface.
  • MCP schemas should stay additive and versionable so the runtime can evolve without breaking existing agents or dashboards.

Frequently Asked Questions

What does KakaoTalk Native MCP add to KakaoTalk?
KakaoTalk Native MCP adds a dedicated AI runtime for KakaoTalk so the platform can manage execution, insights, and policy through one consistent mcp surface.
Who can manage the full mcp configuration?
Standard permissions can install and use the mcp. Ranks that include root access can manage the complete mcp surface, including runtime policy, credentials, execution rules, security settings, and recovery controls.
What changes when a root-access rank manages the mcp?
Root-access management unlocks the full operational surface for the mcp, including installation control, runtime policy, credentials, execution rules, analytics settings, and recovery actions.
What will the user normally see?
The user sees the performance summary, health signals, and analytics relevant to KakaoTalk. They do not need to manage low-level runtime mechanics to benefit from the mcp.