Skip to main content
Glama

register_developer

Register a developer account to obtain an API key after email verification. Provide username and email.

Instructions

Register a developer account on AI Skill Store. API key is issued after email verification. / 개발자 계정 등록. 이메일 인증 후 API 키가 발급됩니다 (보안을 위해 즉시 발급되지 않음).

Args: username: 사용할 username (영문/숫자, 3자 이상, 중복 불가) email: 인증용 이메일 주소 (필수 — 인증 링크가 발송됨)

Returns: 등록 결과 메시지. 이메일 인증 후 API 키를 받을 수 있습니다.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
usernameYes
emailYes

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Implementation Reference

  • The main handler function for the 'register_developer' MCP tool. Sends a POST request to /v1/owners/register with username and email, then returns the registration result (pending email verification, success with API key, or error).
    def register_developer(username: str, email: str) -> str:
        """
        Register a developer account on AI Skill Store. API key is issued after email verification. / 개발자 계정 등록.
        이메일 인증 후 API 키가 발급됩니다 (보안을 위해 즉시 발급되지 않음).
    
        Args:
            username: 사용할 username (영문/숫자, 3자 이상, 중복 불가)
            email: 인증용 이메일 주소 (필수 — 인증 링크가 발송됨)
    
        Returns:
            등록 결과 메시지. 이메일 인증 후 API 키를 받을 수 있습니다.
        """
        payload = {"username": username, "email": email}
    
        result = _post("/v1/owners/register", payload)
    
        status = result.get("status", "")
        if status == "pending_verification":
            return (
                f"✅ 계정 등록 완료! 이메일 인증이 필요합니다.\n"
                f"username : {username}\n"
                f"owner_id : {result.get('owner_id', 'N/A')}\n\n"
                f"📧 {email} 으로 인증 메일이 발송되었습니다.\n"
                f"이메일의 인증 링크를 클릭하면 API 키가 발급됩니다.\n"
                f"발급된 API 키로 upload_skill을 호출할 수 있습니다."
            )
        elif status == "success":
            # 이메일 인증이 불필요한 경우 (향후 변경될 수 있음)
            return (
                f"✅ 계정 등록 성공!\n"
                f"username : {result.get('username', username)}\n"
                f"owner_id : {result.get('owner_id')}\n"
                f"api_key  : {result.get('api_key')}\n\n"
                f"⚠️  api_key는 다시 조회할 수 없습니다. 반드시 지금 저장하세요.\n"
                f"이 api_key를 upload_skill 호출 시 사용하세요."
            )
        else:
            msg = result.get("message", str(result))
            return f"❌ 등록 실패: {msg}"
  • The @mcp.tool() decorator registers 'register_developer' as an MCP tool on the FastMCP server instance.
    @mcp.tool()
  • The _post helper function is used by register_developer to make the HTTP POST request to the backend API.
    def _post(path: str, data: dict, headers: dict = None) -> dict:
        url = SKILL_STORE_URL + path
        body = json.dumps(data).encode()
        req = urllib.request.Request(url, data=body,
                                      headers={"Content-Type": "application/json", **(headers or {})},
                                      method="POST")
        try:
            with urllib.request.urlopen(req, timeout=10) as resp:
                return json.loads(resp.read().decode())
        except urllib.error.HTTPError as e:
            return {"status": "error", "message": f"HTTP {e.code}: {e.reason}"}
        except Exception as e:
            return {"status": "error", "message": str(e)}
  • The _log_tool decorator is applied to register_developer (via @_log_tool) to log tool calls to stdout.
    def _log_tool(fn):
        """각 MCP tool 호출을 stdout 에 한 줄 기록 — journalctl 에서 grep 가능.
        형식: TOOL_CALL tool=<name> kw=<arg_keys>  (PII 회피 위해 값은 로그 X)
        """
        @_functools_tool.wraps(fn)
        def _wrapper(*args, **kwargs):
            try:
                kw_keys = list(kwargs.keys())
                print(f"TOOL_CALL tool={fn.__name__} kw={kw_keys}", flush=True)
            except Exception:
                pass
            return fn(*args, **kwargs)
        return _wrapper
Behavior3/5

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

No annotations are provided, so the description must disclose behavioral traits. It mentions email verification and delayed API key issuance, but lacks details on failure modes (e.g., duplicate username) or side effects. The 'Returns' section is somewhat vague.

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

Conciseness4/5

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

The description is structured with separate sections for args and returns, and includes bilingual text. It is clear but slightly verbose; could be more concise but not wasteful.

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

Completeness3/5

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

For a registration tool with 2 parameters and an output schema, the description covers the core flow but omits important details like validation rules, duplicate handling, and format specifics. An output schema exists, reducing some burden, but more depth would improve completeness.

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

Parameters4/5

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

Input schema has no descriptions (0% coverage). The description adds meaning to both parameters: username constraints (English/numbers, 3+ chars, unique) and email purpose (required, verification link sent). This compensates for the schema gap.

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

Purpose5/5

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

The description clearly states the action ('Register a developer account') and the resource ('AI Skill Store'), distinguishing it from sibling tools like upload_skill or get_skill. The bilingual text reinforces the purpose.

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

Usage Guidelines4/5

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

The description explains the email verification step and that the API key is not immediate, but does not explicitly state when to use this tool vs alternatives. However, given the tool name and sibling list, usage context is clear.

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/garasegae/aiskillstore'

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