Skip to main content
Glama
jjunmomo

BaaS SMS/MCP Server

by jjunmomo

get_integration_guide

Fetch platform-specific integration guides for SMS/MMS messaging via BaaS API, tailored to DevOps setups and deployment scenarios like production, staging, or development.

Instructions

Get detailed integration guide by fetching from CDN for specific platforms and deployment scenarios

Perfect for: DevOps setup, deployment planning, team onboarding
Token-optimized: Fetches comprehensive guides from CDN instead of hardcoded responses

Args:
    platform: Target platform (vercel, netlify, heroku, aws, gcp, azure, docker, etc.)
    deployment_type: Deployment type (development, staging, production)
    
Returns:
    Step-by-step integration guide with platform-specific instructions fetched from CDN
    Updated for new /api/message/ endpoints and X-API-KEY authentication

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
deployment_typeNoproduction
platformYes

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Implementation Reference

  • The handler function for the 'get_integration_guide' tool, decorated with @mcp.tool() for automatic registration in FastMCP. It fetches detailed platform-specific integration guides from a CDN or falls back to predefined guides for platforms like vercel, netlify, and docker. Includes input validation, error handling, and returns structured responses with security checklists and API update information.
    @mcp.tool()
    async def get_integration_guide(
        platform: str,
        deployment_type: str = "production"
    ) -> Dict[str, Any]:
        """
        Get detailed integration guide by fetching from CDN for specific platforms and deployment scenarios
        
        Perfect for: DevOps setup, deployment planning, team onboarding
        Token-optimized: Fetches comprehensive guides from CDN instead of hardcoded responses
        
        Args:
            platform: Target platform (vercel, netlify, heroku, aws, gcp, azure, docker, etc.)
            deployment_type: Deployment type (development, staging, production)
            
        Returns:
            Step-by-step integration guide with platform-specific instructions fetched from CDN
            Updated for new /api/message/ endpoints and X-API-KEY authentication
        """
        try:
            platform = platform.lower()
            deployment_type = deployment_type.lower()
            
            # Try to fetch guide from CDN
            guide_url = f"https://cdn.mbaas.kr/templates/sms-mms/deployment/{platform}-{deployment_type}.md"
            
            try:
                response = await client.get(guide_url)
                if response.status_code == 200:
                    guide_content = response.text
                    
                    return {
                        "success": True,
                        "platform": platform,
                        "deployment_type": deployment_type,
                        "guide_content": guide_content,
                        "source": "CDN",
                        "guide_url": guide_url,
                        "api_changes": {
                            "endpoints": "Updated to /api/message/sms and /api/message/mms",
                            "authentication": "X-API-KEY header only (no project_id needed)",
                            "breaking_changes": "Project ID parameter removed from API calls"
                        },
                        "security_checklist": [
                            "API 키를 코드에 하드코딩하지 않기",
                            "환경 변수 또는 시크릿 관리 서비스 사용",
                            "HTTPS 통신 확인",
                            "적절한 에러 로깅 설정"
                        ],
                        "message": f"{platform.title()} {deployment_type} 배포 가이드입니다 (CDN 최적화)"
                    }
            except Exception:
                # Fallback to basic guides if CDN unavailable
                pass
            
            # Fallback guides with updated API information
            basic_guides = {
                "vercel": {
                    "title": "Vercel 배포 가이드",
                    "steps": [
                        "1. 환경 변수 설정: BAAS_API_KEY (PROJECT_ID 불필요)",
                        "2. vercel.json 설정에 환경 변수 추가",
                        "3. API Routes에서 /api/message/ 엔드포인트 사용",
                        "4. X-API-KEY 헤더로 인증 처리"
                    ],
                    "config": {
                        "env_vars": "Vercel Dashboard > Settings > Environment Variables",
                        "api_routes": "/api/send-sms.js 형태로 구현",
                        "endpoints": "/api/message/sms, /api/message/mms"
                    }
                },
                "netlify": {
                    "title": "Netlify Functions 가이드",
                    "steps": [
                        "1. netlify/functions 디렉토리에 함수 생성",
                        "2. 환경 변수 BAAS_API_KEY를 Netlify 대시보드에서 설정",
                        "3. X-API-KEY 헤더로 인증하는 함수 구현",
                        "4. /api/message/ 엔드포인트 사용"
                    ]
                },
                "docker": {
                    "title": "Docker 컨테이너 배포",
                    "steps": [
                        "1. Dockerfile에 필요한 의존성 설치",
                        "2. ENV BAAS_API_KEY로 환경 변수 설정",
                        "3. 또는 docker run -e BAAS_API_KEY 옵션 사용",
                        "4. 네트워크 접근성 확인 (api.aiapp.link/api/message/)"
                    ]
                }
            }
            
            guide = basic_guides.get(platform)
            
            if not guide:
                return {
                    "success": False,
                    "error": f"플랫폼 '{platform}'에 대한 가이드가 아직 준비되지 않았습니다",
                    "available_platforms": list(basic_guides.keys()),
                    "cdn_url": f"https://cdn.mbaas.kr/templates/sms-mms/deployment/",
                    "error_code": "PLATFORM_NOT_SUPPORTED"
                }
            
            # Add deployment-specific notes
            deployment_notes = {
                "development": "개발 환경에서는 .env 파일 사용 권장",
                "staging": "스테이징 환경에서는 별도 API 키 사용",
                "production": "프로덕션에서는 환경 변수 암호화 및 로깅 설정 필요"
            }
            
            return {
                "success": True,
                "platform": platform,
                "deployment_type": deployment_type,
                "guide": guide,
                "source": "Local fallback",
                "deployment_notes": deployment_notes.get(deployment_type, ""),
                "api_changes": {
                    "endpoints": "Updated to /api/message/sms and /api/message/mms",
                    "authentication": "X-API-KEY header only (no project_id needed)",
                    "breaking_changes": "Project ID parameter removed from API calls"
                },
                "security_checklist": [
                    "API 키를 코드에 하드코딩하지 않기",
                    "환경 변수 또는 시크릿 관리 서비스 사용",
                    "HTTPS 통신 확인",
                    "적절한 에러 로깅 설정"
                ],
                "message": f"{platform.title()} {deployment_type} 배포 가이드입니다 (로컬 폴백)"
            }
            
        except Exception as e:
            return {
                "success": False,
                "error": f"가이드 조회에 실패했습니다: {str(e)}",
                "error_code": "GUIDE_RETRIEVAL_ERROR"
            }
Behavior3/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context about fetching from a CDN, token optimization, and updates for new endpoints and authentication, which goes beyond basic functionality. However, it lacks details on potential errors, rate limits, or performance characteristics that would be helpful for a tool interacting with external resources.

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 well-structured with sections for purpose, usage context, optimization note, arguments, and returns. Each sentence adds value, such as the token optimization note and endpoint updates. It could be slightly more concise by integrating some details, but overall it's efficient and front-loaded with key information.

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

Completeness4/5

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

Given the tool has an output schema, the description doesn't need to explain return values in detail, and it appropriately summarizes them. With no annotations and low schema coverage, the description compensates well by covering purpose, usage, parameters, and behavioral context like CDN fetching and updates. It's nearly complete for a retrieval tool, though minor gaps remain in error handling or advanced usage scenarios.

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?

Schema description coverage is 0%, so the description must compensate. It provides meaningful semantics for both parameters: 'platform' is described with examples (e.g., vercel, netlify, docker) and 'deployment_type' with options (development, staging, production). This adds significant value beyond the bare schema, though it doesn't specify format constraints or default behaviors beyond the schema's default for deployment_type.

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 fetches integration guides from a CDN for specific platforms and deployment scenarios, using specific verbs ('Get detailed integration guide by fetching from CDN') and resources ('platforms and deployment scenarios'). It distinguishes from siblings like 'create_message_service_template' or 'generate_direct_api_code' by focusing on retrieval rather than creation or generation. However, it doesn't explicitly contrast with siblings beyond the general 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 provides clear context for when to use the tool ('Perfect for: DevOps setup, deployment planning, team onboarding') and mentions optimization aspects ('Token-optimized: Fetches from CDN instead of hardcoded responses'), which helps guide usage. It doesn't explicitly state when not to use it or name alternatives among siblings, but the context is sufficiently detailed to infer appropriate 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

Related 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/jjunmomo/BaaS-MCP'

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