카카오톡과 AI 업무 시스템 연결: 수신·처리·발송 구조

카카오 메시지 API, 알림톡과 챗봇의 역할을 구분하고 AI 업무 자동화의 권한과 승인 흐름을 설명합니다.

Robotext2026년 2월 9일수정 2026. 10. 28.6분 읽기

카카오톡 업무 자동화는 챗봇이 요청을 받고, 서버가 사용자 권한과 입력을 확인한 뒤, 업무 시스템의 결과를 응답하는 구조로 만듭니다. 매출 조회와 일정 등록을 같은 대화 화면에 넣더라도, 조회 권한·승인·실행 결과는 업무별로 분리합니다. 여기서는 공식 스킬 요청을 받아 매출을 조회하고 일정 초안을 저장하는 흐름을 살펴봅니다.

먼저 수신 경로와 발송 경로를 고릅니다

필요한 일사용할 경로설계할 내용
채널에서 업무 명령 받기카카오 채널 챗봇·스킬 서버블록·스킬 요청·사용자 계정 연결
본인 또는 허용 대상에게 메시지 보내기카카오톡 메시지 API로그인·동의·대상과 사용 권한
고객에게 정보성 알림 보내기비즈메시지 알림톡발송 자격·템플릿·결과 기록

챗봇 수신과 별도 메시지 발송은 다른 연동입니다. 메시지 API 안내와 FAQ에서 발송 대상과 권한을 확인하고, 명령 수신은 챗봇 스킬 가이드로 설계합니다.

챗봇이 요청을 받고 서버가 권한을 확인한 뒤 실행합니다
  1. 수신

    • 사용자 → 채널 챗봇
    • 스킬 요청 수신부
  2. 실행 전 검사

    • 사내 계정 연결
    • 의도·입력 추출
    • 허용 도구·권한 확인
  3. 업무 실행

    • 매출 조회
    • 승인된 변경 작업
  4. 결과 전달

    • 결과·실패 상태 저장
    • 스킬 응답 구성

코드는 외부 통신 없이 SQLite 메모리 DB의 조회와 일정 초안 저장을 실행합니다.

1. 스킬 요청과 응답: 공식 필드를 업무 입력으로 연결하기

스킬 요청에서 userRequest.utterance는 발화, userRequest.user는 사용자 식별 정보, action.params는 추출한 파라미터입니다. 다음 JSON은 조회 스킬에서 사용할 필드만 추린 형태입니다. month는 이 업무에서 설정한 파라미터 이름입니다.

{
  "bot": {"id": "bot-demo", "name": "업무 비서"},
  "intent": {"id": "sales-block", "name": "매출 조회"},
  "userRequest": {
    "utterance": "2026년 10월 매출 알려줘",
    "user": {"id": "u-17", "type": "botUserKey"},
    "lang": "ko", "timezone": "Asia/Seoul"
  },
  "action": {
    "id": "sales-skill", "name": "query_sales",
    "params": {"month": "2026-10"}, "detailParams": {}, "clientExtra": {}
  }
}

텍스트 응답은 다음처럼 version: "2.0", template.outputs, simpleText.text로 구성합니다. 공식 요청·응답 포맷을 2026-10-28에 확인했습니다.

{
  "version": "2.0",
  "template": {
    "outputs": [{"simpleText": {"text": "2026-10 매출 52,000,000원 / 집계 기준 2026-10-27"}}]
  }
}

botUserKey는 봇별 사용자 식별값이므로 사내 직원 번호와 연결하는 절차를 둡니다. 아래 코드의 (bot.id, user.type, user.id) 매핑은 계정 연결을 끝낸 서버 측 자료입니다. 서버는 대화에 적은 이름이나 clientExtra의 승인값 대신, 연결한 사내 계정의 권한으로 실행 여부를 판단합니다.

2. 의도와 도구: 입력·출력 계약을 먼저 정하기

정해진 블록에서는 action.name을 허용된 도구에 매핑합니다. 자유 발화를 AI로 해석할 때도 모델은 도구 이름과 인수를 제안하고, 서버가 같은 검사 함수를 거쳐 실행합니다. “이번 달”은 기준 시각과 시간대로 확정하고, 날짜가 빠졌거나 모호하면 실행 전에 되묻습니다.

  • 매출 조회(query_sales): month를 YYYY-MM 형식으로 받습니다. 서버는 sales.read 권한과 허용 조회 범위를 확인하고 월·매출 합계·통화·집계 기준일을 반환합니다.
  • 일정 저장(schedule_meeting): date·time·attendees를 받습니다. 서버는 calendar.write 권한·시간대·참석자·승인한 내용의 일치를 확인하고 업무 키·로컬 초안 ID·저장 상태를 반환합니다.
가상 예시: 같은 매출 질문, 권한에 따라 다른 응답

같은 요청: 2026년 10월 매출 알려줘

  • u-17 직원: 매출 조회 권한 있음
  • u-18 직원: 매출 조회 권한 없음

서버가 확인한 뒤 보내는 응답

  • u-17 → 2026-10 매출 52,000,000원
  • u-17 집계 기준: 2026-10-27
  • u-18 → 이 업무의 실행 권한이 없습니다.

이 글의 사용자·매출·일정은 아래 로컬 코드로 실행하는 예시입니다.

예를 들어 내부 표준 도구 요청을 다음과 같이 맞춥니다. 이 객체는 서버 내부 계약이며, 선택한 모델 제공자의 도구 호출 응답은 이 구조로 변환합니다.

{"name":"query_sales","arguments":{"month":"2026-10"}}

일정 도구의 내부 입력은 date: "2026-10-29", time: "14:00", attendees: ["staff-2"]처럼 확정한 값입니다. 스킬의 action.params 값은 문자열이므로 참석자 배열은 JSON 문자열로 받고, tool_args에서 내부 배열로 변환합니다. 도구 실행 결과를 응답 문장으로 바꿀 때도 합계와 날짜·상태는 결과 객체에서 가져옵니다.

3. 로컬 구현: 사용자 연결부터 업무 결과까지 실행하기

다음 코드는 Python 표준 라이브러리로 실행할 수 있습니다. handle이 스킬 수신 후의 처리 함수이고, query_sales와 save_draft가 업무 어댑터입니다. 웹 서버에서는 JSON 요청을 읽어 이 함수에 전달하고 반환한 객체를 JSON 응답으로 보냅니다. 실제 서비스의 요청 수신부에는 접근 통제와 요청 크기 제한을 적용합니다.

import copy
import hashlib
import json
import re
import sqlite3
from datetime import date, time
 
DB = sqlite3.connect(":memory:")
DB.execute("CREATE TABLE sales(month TEXT PRIMARY KEY, total INTEGER, as_of TEXT)")
DB.execute("INSERT INTO sales VALUES ('2026-10', 52000000, '2026-10-27')")
DB.execute("CREATE TABLE drafts(job_key TEXT PRIMARY KEY, payload TEXT NOT NULL)")
DB.commit()
ACCOUNTS = {
    ("bot-demo", "botUserKey", "u-17"): {
        "id": "staff-1", "active": True, "roles": {"sales.read", "calendar.write"}},
    ("bot-demo", "botUserKey", "u-18"): {
        "id": "staff-2", "active": True, "roles": set()},
}
# 로컬 시험용 승인 자료입니다.
APPROVALS = {}
 
def skill(text):
    return {"version": "2.0", "template": {"outputs": [{"simpleText": {"text": text}}]}}
 
def text_of(response):
    return response["template"]["outputs"][0]["simpleText"]["text"]
 
def query_sales(args):
    month = args.get("month", "")
    if not isinstance(month, str) or not re.fullmatch(r"\d{4}-(0[1-9]|1[0-2])", month):
        return {"status": "needs_input", "message": "조회할 월을 YYYY-MM으로 알려 주세요."}
    row = DB.execute("SELECT total, as_of FROM sales WHERE month = ?", (month,)).fetchone()
    if row is None:
        return {"status": "no_data", "message": f"{month} 집계 자료가 없습니다."}
    return {"status": "ok", "month": month, "total": row[0], "currency": "KRW", "as_of": row[1]}
 
def tool_args(name, params):
    if not isinstance(params, dict) or any(not isinstance(v, str) for v in params.values()):
        raise ValueError("스킬 파라미터는 문자열이어야 합니다")
    args = dict(params)
    if name == "schedule_meeting" and "attendees" in args:
        args["attendees"] = json.loads(args["attendees"])
    return args
 
def draft_payload(args):
    day, clock, attendees = args.get("date"), args.get("time"), args.get("attendees")
    if not isinstance(day, str) or not re.fullmatch(r"\d{4}-\d{2}-\d{2}", day):
        raise ValueError("date")
    if not isinstance(clock, str) or not re.fullmatch(r"\d{2}:\d{2}", clock):
        raise ValueError("time")
    date.fromisoformat(day)
    time.fromisoformat(clock)
    if not isinstance(attendees, list) or not attendees or any(
        not isinstance(x, str) or x not in {"staff-1", "staff-2"} for x in attendees
    ):
        raise ValueError("attendees")
    return {"date": day, "time": clock, "attendees": sorted(set(attendees)),
            "timezone": "Asia/Seoul"}
 
def job_identity(employee, payload):
    canonical = json.dumps({"employee": employee, "tool": "schedule_meeting", **payload},
                           ensure_ascii=False, sort_keys=True)
    return hashlib.sha256(canonical.encode()).hexdigest()
 
def save_draft(employee, args):
    try:
        payload = draft_payload(args)
    except (ValueError, TypeError):
        return {"status": "needs_input", "message": "날짜·시간·사내 참석자를 확인해 주세요."}
    key = job_identity(employee, payload)
    approval = APPROVALS.get(key)
    if approval != {"requester": employee, "approver": "manager-1", "payload": payload}:
        return {"status": "awaiting_approval", "job_key": key, "payload": payload}
    # 업무 키의 고유 제약으로 같은 요청의 중복 저장을 막습니다.
    with DB:
        DB.execute("INSERT OR IGNORE INTO drafts VALUES (?, ?)",
                   (key, json.dumps(payload, ensure_ascii=False, sort_keys=True)))
    return {"status": "local_draft_saved", "job_key": key, "draft_id": key[:12]}
 
def handle(body):
    try:
        user = body["userRequest"]["user"]
        utterance = body["userRequest"]["utterance"]
        if not isinstance(utterance, str) or not utterance.strip() or len(utterance) > 2000:
            return skill("요청 내용을 2,000자 이내로 알려 주세요.")
        employee = ACCOUNTS.get((body["bot"]["id"], user["type"], user["id"]))
        if not employee or not employee["active"]:
            return skill("사내 계정을 먼저 연결해 주세요.")
        name = body["action"]["name"]
        args = tool_args(name, body["action"].get("params", {}))
        required_role = {"query_sales": "sales.read", "schedule_meeting": "calendar.write"}.get(name)
        if required_role is None:
            return skill("지원하는 업무를 선택해 주세요.")
        if required_role not in employee["roles"]:
            return skill("이 업무의 실행 권한이 없습니다.")
        result = query_sales(args) if name == "query_sales" else save_draft(employee["id"], args)
        if result["status"] == "ok":
            return skill(f'{result["month"]} 매출 {result["total"]:,}원 / 집계 기준 {result["as_of"]}')
        if result["status"] == "awaiting_approval":
            return skill("일정 내용 확인과 승인을 기다립니다.")
        if result["status"] == "local_draft_saved":
            return skill(f'로컬 일정 초안 저장: {result["draft_id"]}')
        return skill(result["message"])
    except sqlite3.Error:
        return skill("업무 저장소 확인이 필요합니다. 처리 상태를 조회한 뒤 다시 시도합니다.")
    except (KeyError, TypeError, ValueError):
        return skill("요청 형식을 확인해 주세요.")
 
request = {
    "bot": {"id": "bot-demo"},
    "userRequest": {"utterance": "10월 매출", "user": {"id": "u-17", "type": "botUserKey"}},
    "action": {"name": "query_sales", "params": {"month": "2026-10"}}
}
assert "52,000,000원" in text_of(handle(request))
assert handle(request)["version"] == "2.0"
missing = copy.deepcopy(request)
missing["action"]["params"] = {}
assert "YYYY-MM" in text_of(handle(missing))
unknown = copy.deepcopy(request)
unknown["userRequest"]["user"]["id"] = "unknown"
assert "계정을 먼저 연결" in text_of(handle(unknown))
denied = copy.deepcopy(request)
denied["userRequest"]["user"]["id"] = "u-18"
assert "권한이 없습니다" in text_of(handle(denied))
meeting = copy.deepcopy(request)
meeting["action"] = {"name": "schedule_meeting", "params": {
    "date": "2026-10-29", "time": "14:00", "attendees": json.dumps(["staff-2"])}}
assert "승인을 기다립니다" in text_of(handle(meeting))
payload = draft_payload(tool_args("schedule_meeting", meeting["action"]["params"]))
key = job_identity("staff-1", payload)
APPROVALS[key] = {"requester": "staff-1", "approver": "manager-1", "payload": payload}
assert "로컬 일정 초안 저장" in text_of(handle(meeting))
assert handle(meeting) == handle(meeting)
assert DB.execute("SELECT COUNT(*) FROM drafts").fetchone()[0] == 1
meeting["action"]["params"]["time"] = "15:00"
assert "승인을 기다립니다" in text_of(handle(meeting))
print(json.dumps({"success": handle(request), "missing_month": handle(missing),
                  "unlinked": handle(unknown)}, ensure_ascii=False))
DB.close()
assert "업무 저장소 확인" in text_of(handle(request))

마지막 검사는 저장소 장애 때 처리 상태 확인을 안내하는지 확인합니다. 로컬 시험에서는 APPROVALS 사전에 승인 내용을 넣습니다. 실제 서비스는 인증한 승인자의 권한을 확인하고, 승인 시각·대상·내용 버전을 영속 승인 원장에 기록합니다.

4. 업무 키와 승인: 같은 요청을 다시 받아도 이어서 처리하기

업무 키는 같은 업무인지 판단하는 식별자입니다. 위 코드는 요청자·도구·확정 일정으로 키를 만들고 DB의 고유 제약으로 중복 초안을 막습니다. 같은 일정이라도 별개 회의일 수 있는 서비스에서는 요청을 접수할 때 만든 업무 ID를 사용합니다. 재시도는 같은 업무 ID를 이어받고, 사용자가 새로 의뢰한 업무에는 새 ID를 부여합니다.

외부 캘린더를 연결할 때는 로컬 초안 저장 뒤 전송 대기 → 전송 중 → 외부 등록 확인을 추가합니다. 공급자가 지원하는 중복 실행 방지 키(멱등 키)나 외부 일정 ID를 보관하고, 타임아웃 때 해당 ID로 등록 여부부터 조회합니다. 내용이 바뀌면 승인 대상을 새 버전으로 만들고 재승인합니다. 중복 실행 방지에서 재처리 기준을 이어 볼 수 있습니다.

승인한 14:00은 저장하고 변경한 15:00은 다시 승인받습니다
  1. 승인한 일정 내용과 같은가요?

    14:00 그대로 →로컬 초안 저장

  2. 내용이 바뀌면 →변경한 15:00으로 재승인

같은 직원·날짜·참석자여도 시간이 달라지면 기존 승인을 재사용하지 않습니다.

5. 실패·장시간 작업·운영 비용을 설계하기

상황사용자에게 보여줄 결과운영자가 이어서 할 일
계정 연결 실패·권한 없음연결 안내 또는 권한 안내계정 연결·퇴사자 권한 철회 점검
기간·참석자 누락필요한 항목 질문입력 보완 후 같은 업무에 연결
조회 자료 없음자료 없음과 조회 범위수집 누락 여부 확인
저장·외부 API 실패실패 단계·처리 상태완료 기록 확인 후 미완료 단계 재시도
처리 시간이 길어짐접수 상태·조회 방법작업 대기열 처리와 결과 전달 경로 확인

응답 시간과 장시간 작업은 선택한 챗봇 기능의 현재 조건에 맞춰 구성합니다. 콜백 기능을 사용할 때는 공식 콜백 가이드의 활성화·요청·응답 방식을 적용합니다. 알림톡으로 결과를 보낼 때는 발송 자격과 템플릿을 확인하고 별도 발송 작업의 결과를 기록합니다.

운영 기록과 비용 확인
  • 운영 기록

    • 업무 ID·사용자 연결 ID·도구 기록
    • 입력 버전·승인자·상태·외부 결과 ID 기록
  • API 키와 로그

    • API 키는 서버 저장소에서 관리
    • 로그에는 필요한 식별자·사유 코드 기록
  • 비용

    • 챗봇·메시지 발송·모델 사용량 구분
    • 서버·검수·유지보수 비용 구분

어떤 경로로 몇 건을 받거나 보내는지 정하면 실제 견적과 월 사용료를 비교하기 쉽습니다.

로보텍스트는 카카오 수신 경로와 사내 계정을 연결하고, 도구별 입력·승인·실패·재처리까지 업무 흐름을 설계합니다. 카카오톡으로 요청할 업무와 연결할 시스템을 hello@robotext.co.kr로 알려 주세요.

관련 글: 업무 워크플로우 5가지 · AI 실행 승인 설계 · 카카오 메시지 경로 선택

로보텍스트와 업무에 적용하기

반복 업무를 설명해 주세요. 구현할 순서를 잡겠습니다

문의에 적어주실 내용
현재 작업 순서, 사용하는 프로그램과 반복 주기. 가린 예시나 업무 설명이면 충분합니다.
함께 정할 내용
우선 자동화할 작업, 연결 방법과 사람이 승인할 단계을 정리합니다.
업무 자동화 문의하기

hello@robotext.co.kr

관련 글

공유하기