Real-time web search has become essential in today's information-driven environment, where applications need immediate access to up-to-date information across the internet to provide relevant and timely responses.
The Model Context Protocol (MCP) represents a significant advancement in optimizing these real-time search processes, enhancing search efficiency, maintaining contextual integrity, and improving overall system performance.
This module explores how MCP transforms real-time web search by providing a standardized approach to context management across AI models, search engines, and applications.
In this comprehensive guide, you'll discover:
Real-time web search is a technological approach that enables continuous querying, processing, and analysis of web-based information as it's published or updated, allowing systems to provide fresh and relevant information with minimal latency.
Unlike traditional search systems that operate on indexed data which may be hours or days old, real-time search processes live data from the web, delivering insights and information that reflect the current state of online content.
The Model Context Protocol (MCP) addresses several critical challenges in real-time web search environments:
1. Search Context Preservation: MCP standardizes how context is maintained across distributed search components, ensuring that AI models and processing nodes have access to relevant query history and user preferences.
2. Efficient Query Management: By providing structured mechanisms for context transmission, MCP reduces the overhead of repeating context in each search iteration.
3. Interoperability: MCP creates a common language for context sharing between diverse search technologies and AI models, enabling more flexible and extensible architectures.
4. Search-Optimized Context: MCP implementations can prioritize which context elements are most relevant for effective search, optimizing for both performance and accuracy.
5. Adaptive Search Processing: With proper context management through MCP, search systems can dynamically adjust processing based on evolving user needs and information landscapes.
In modern applications ranging from news aggregation to research assistants, the integration of MCP with web search technologies enables more intelligent, context-aware search that can provide increasingly relevant results as user interactions continue.
By the end of this lesson, you will be able to:
Real-time web search involves the continuous querying, retrieval, and delivery of web-based information with minimal latency.
Unlike traditional search engines that periodically crawl and index the web, real-time search aims to surface information as it becomes available, enabling immediate access to the most current content.
Key characteristics of real-time web search include:
Traditional web search approaches face several limitations when applied to real-time scenarios:
1. Context Fragmentation: Difficulty maintaining search context across multiple queries
2. Information Freshness: Challenges in accessing and prioritizing the most recent information
3. Integration Complexity: Problems with interoperability between search systems and applications
4. Latency Issues: Balancing comprehensive search with response time requirements
5. Relevance Tuning: Ensuring accuracy and relevance while prioritizing recency
The Model Context Protocol (MCP) is a standardized communication protocol designed to facilitate efficient interaction between AI models and applications. In the context of real-time web search, MCP provides a framework for:
MCP architecture for real-time web search consists of several key components:
1. Query Context Handlers: Manage and maintain search context across multiple queries
2. Search Processors: Process incoming search requests using context-aware techniques
3. Protocol Adapters: Convert between different search APIs while preserving context
4. Context Store: Efficiently store and retrieve search history and preferences
5. Search Connectors: Connect to various search engines and web APIs
graph TD
subgraph "Data Sources"
Web[Web Content]
APIs[External APIs]
DB[Knowledge Bases]
News[News Feeds]
end
subgraph "MCP Search Layer"
SC[Search Connectors]
PA[Protocol Adapters]
CH[Context Handlers]
SP[Search Processors]
CS[Context Store]
end
subgraph "Processing & Analysis"
RE[Relevance Engine]
ML[ML Models]
NLP[NLP Processing]
Rank[Ranking System]
end
subgraph "Applications & Services"
RA[Research Assistant]
Alerts[Alert Systems]
KB[Knowledge Base]
API[API Services]
end
Web -->|Content| SC
APIs -->|Data| SC
DB -->|Knowledge| SC
News -->|Updates| SC
SC -->|Raw Results| PA
PA -->|Normalized Results| CH
CH <-->|Context Operations| CS
CH -->|Context-Enriched Results| SP
SP -->|Processed Results| RE
SP -->|Features| ML
SP -->|Text| NLP
RE -->|Ranked Results| Rank
ML -->|Predictions| Rank
NLP -->|Entities & Relations| Rank
Rank -->|Final Results| RA
ML -->|Insights| Alerts
NLP -->|Structured Data| KB
RA -->|Research| Users((Users))
Alerts -->|Notifications| Users
KB <-->|Knowledge Access| API
classDef sources fill:#f9f,stroke:#333,stroke-width:2px
classDef mcp fill:#bbf,stroke:#333,stroke-width:2px
classDef processing fill:#bfb,stroke:#333,stroke-width:2px
classDef apps fill:#fbb,stroke:#333,stroke-width:2px
class Web,APIs,DB,News sources
class SC,PA,CH,SP,CS mcp
class RE,ML,NLP,Rank processing
class RA,Alerts,KB,API apps
MCP addresses traditional web search challenges through:
Real-time web search systems require careful architectural design and implementation to maintain both performance and contextual integrity.
The Model Context Protocol offers a standardized approach to integrating AI models and search technologies, allowing for more sophisticated, context-aware search pipelines.
Implementing MCP in real-time web search environments involves several key considerations:
1. Search Context Serialization: MCP provides efficient mechanisms for encoding contextual information within search requests, ensuring that essential context follows the query throughout the processing pipeline.
This includes standardized serialization formats optimized for search-related metadata.
2. Stateful Search Processing: MCP enables more intelligent stateful processing by maintaining consistent context representation across search iterations.
This is particularly valuable in multi-stage search pipelines where context refinement improves results.
3. Query Expansion and Refinement: MCP implementations in search systems can facilitate sophisticated query expansion and refinement based on accumulated context, allowing for increasingly relevant results as the search session progresses.
4. Result Caching and Prioritization: By standardizing context handling, MCP helps manage result caching and prioritization, allowing components to adapt based on the evolving search context.
5. Search Federation and Aggregation: MCP facilitates more sophisticated federation of search across multiple backends by providing structured representations of search context, enabling more meaningful aggregation of results from diverse sources.
The implementation of MCP across various search technologies creates a unified approach to context management, reducing the need for custom integration code while enhancing the system's ability to maintain meaningful context as search queries evolve.
These examples follow the current MCP specification which focuses on a JSON-RPC based protocol with distinct transport mechanisms.
The code demonstrates how you can implement custom search integrations while maintaining full compatibility with the MCP protocol.
import asyncio
import json
import aiohttp
from typing import Dict, Any, Optional, List
from contextlib import asynccontextmanager
from collections.abc import AsyncIterator
# Import standard MCP libraries
from mcp.client.session import ClientSession
from mcp.client.streamable_http import streamablehttp_client
from mcp.types import TextContent, CreateMessageRequestParams, CreateMessageResult
from mcp.server.fastmcp import FastMCP
# Create a FastMCP server for web search
search_server = FastMCP("WebSearch")
# Class to handle web search operations
class WebSearchHandler:
def __init__(self, api_endpoint: str, api_key: str):
self.api_endpoint = api_endpoint
self.api_key = api_key
self.session = None
async def initialize(self):
"""Initialize the HTTP session"""
self.session = aiohttp.ClientSession(
headers={"Authorization": f"Bearer {self.api_key}"}
)
async def close(self):
"""Close the HTTP session"""
if self.session:
await self.session.close()
async def perform_search(self, query: str, max_results: int = 5,
include_domains: List[str] = None,
exclude_domains: List[str] = None,
time_period: str = "any") -> Dict[str, Any]:
"""Perform web search using the search API"""
# Construct search parameters
search_params = {
"q": query,
"limit": max_results,
"time": time_period
}
if include_domains:
search_params["site"] = ",".join(include_domains)
if exclude_domains:
search_params["exclude_site"] = ",".join(exclude_domains)
# Perform the search request
try:
async with self.session.get(
self.api_endpoint,
params=search_params
) as response:
if response.status != 200:
error_text = await response.text()
raise Exception(f"Search API error: {response.status} - {error_text}")
search_data = await response.json()
# Transform API-specific response to a standard format
results = []
for item in search_data.get("results", []):
results.append({
"title": item.get("title", ""),
"url": item.get("url", ""),
"snippet": item.get("snippet", ""),
"date": item.get("published_date", ""),
"source": item.get("source", "")
})
return {
"query": query,
"totalResults": len(results),
"results": results
}
except Exception as e:
print(f"Search API request error: {e}")
raise
# Initialize the search handler
search_handler = WebSearchHandler(
api_endpoint="https://api.search-service.example/search",
api_key="your-api-key-here"
)
# Setup lifespan to manage the search handler
@asyncio.asynccontextmanager
async def app_lifespan(server: FastMCP):
"""Manage application lifecycle"""
await search_handler.initialize()
try:
yield {"search_handler": search_handler}
finally:
await search_handler.close()
# Set lifespan for the server
search_server = FastMCP("WebSearch", lifespan=app_lifespan)
# Register a web search tool
@search_server.tool()
async def web_search(query: str, max_results: int = 5,
include_domains: List[str] = None,
exclude_domains: List[str] = None,
time_period: str = "any") -> Dict[str, Any]:
"""
Search the web for information
Args:
query: The search query
max_results: Maximum number of results to return (default: 5)
include_domains: List of domains to include in search results
exclude_domains: List of domains to exclude from search results
time_period: Time period for results ("day", "week", "month", "any")
Returns:
Dictionary containing search results
"""
ctx = search_server.get_context()
search_handler = ctx.request_context.lifespan_context["search_handler"]
results = await search_handler.perform_search(
query=query,
max_results=max_results,
include_domains=include_domains,
exclude_domains=exclude_domains,
time_period=time_period
)
return results
# Example client usage
async def client_example():
# Connect to the search server using Streamable HTTP transport
async with streamablehttp_client("http://localhost:8000/mcp") as (read, write, _):
async with ClientSession(read, write) as session:
# Initialize the connection
await session.initialize()
# Call the web_search tool
search_results = await session.call_tool(
"web_search",
{
"query": "latest developments in AI and Model Context Protocol",
"max_results": 5,
"time_period": "day",
"include_domains": ["github.com", "microsoft.com"]
}
)
print(f"Search results: {search_results}")
# Server execution example
if __name__ == "__main__":
# Run the server with Streamable HTTP transport
search_server.run(transport="streamable-http")
// MCP server implementation for web search
import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
import { z } from 'zod';
// Create an MCP server for web search
const searchServer = new McpServer({
name: "BrowserSearch",
description: "A server that provides web search capabilities"
});
// Search service class
class SearchService {
constructor(searchApiUrl, apiKey) {
this.searchApiUrl = searchApiUrl;
this.apiKey = apiKey;
}
async performSearch(parameters) {
const {
query = '',
maxResults = 5,
includeDomains = [],
excludeDomains = [],
timePeriod = 'any'
} = parameters;
// Construct search URL with parameters
const url = new URL(this.searchApiUrl);
url.searchParams.append('q', query);
url.searchParams.append('limit', maxResults);
url.searchParams.append('time', timePeriod);
if (includeDomains.length > 0) {
url.searchParams.append('site', includeDomains.join(','));
}
if (excludeDomains.length > 0) {
url.searchParams.append('exclude_site', excludeDomains.join(','));
}
try {
const response = await fetch(url.toString(), {
method: 'GET',
headers: {
'Authorization': `Bearer ${this.apiKey}`,
'Content-Type': 'application/json'
}
});
if (!response.ok) {
const errorText = await response.text();
throw new Error(`Search API error: ${response.status} - ${errorText}`);
}
const searchData = await response.json();
// Transform API-specific response to a standard format
const results = searchData.results?.map(item => ({
title: item.title || '',
url: item.url || '',
snippet: item.snippet || '',
date: item.published_date || '',
source: item.source || ''
})) || [];
return {
query,
totalResults: results.length,
results
};
} catch (error) {
console.error('Search API request error:', error);
throw error;
}
}
}
// Initialize the search service
const searchService = new SearchService(
'https://api.search-service.example/search',
'your-api-key-here'
);
// Setup the context provider for the server
searchServer.setContextProvider(() => {
return {
searchService
};
});
// Register web search tool
searchServer.tool({
name: 'web_search',
description: 'Search the web for information',
parameters: {
type: 'object',
properties: {
query: {
type: 'string',
description: 'The search query'
},
maxResults: {
type: 'integer',
description: 'Maximum number of results to return',
default: 5
},
includeDomains: {
type: 'array',
items: { type: 'string' },
description: 'List of domains to include in search results'
},
excludeDomains: {
type: 'array',
items: { type: 'string' },
description: 'List of domains to exclude from search results'
},
timePeriod: {
type: 'string',
description: 'Time period for results',
enum: ['day', 'week', 'month', 'any'],
default: 'any'
}
},
required: ['query']
},
handler: async (params, context) => {
const { searchService } = context;
return await searchService.performSearch(params);
}
});
// Example client code to connect to the search server
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
async function connectToSearchServer() {
// Connect to the search server
const transport = new StreamableHTTPClientTransport(
new URL('http://localhost:8000/mcp')
);
const client = new Client({
name: 'search-client',
version: '1.0.0'
});
await client.connect(transport);
// Execute the search tool
const searchResults = await client.callTool({
name: 'web_search',
arguments: {
query: 'Model Context Protocol implementation examples',
maxResults: 10,
timePeriod: 'week',
includeDomains: ['github.com', 'docs.microsoft.com']
}
});
console.log('Search results:', searchResults);
// Cleanup
await client.disconnect();
}
// Start the server
const transport = new StreamableHTTPServerTransport();
await searchServer.connect(transport);
console.log('Search server running at http://localhost:8000/mcp');
// In a separate process or after server is started
// connectToSearchServer().catch(console.error);
> Important Note: The code examples below demonstrate the integration of the Model Context Protocol (MCP) with web search functionality.
While they follow the patterns and structures of the official MCP SDKs, they have been simplified for educational purposes.
>
> These examples showcase:
>
> 1. Python Implementation: A FastMCP server implementation that provides a web search tool and connects to an external search API.
This example demonstrates proper lifespan management, context handling, and tool implementation following the patterns of the official MCP Python SDK.
The server utilizes the recommended Streamable HTTP transport which has superseded the older SSE transport for production deployments.
>
> 2. JavaScript Implementation: A TypeScript/JavaScript implementation using the FastMCP pattern from the official MCP TypeScript SDK to create a search server with proper tool definitions and client connections.
It follows the latest recommended patterns for session management and context preservation.
>
> These examples would require additional error handling, authentication, and specific API integration code for production use.
The search API endpoints shown (https://api.search-service.example/search) are placeholders and would need to be replaced with actual search service endpoints.
>
> For complete implementation details and the most up-to-date approaches, please refer to the official MCP specification and SDK documentation.
At its foundation, the Model Context Protocol provides a standardized way for AI models, applications, and services to exchange context.
In real-time web search, this framework is essential for creating coherent, multi-turn search experiences.
Key components include:
1. Client-Server Architecture: MCP establishes a clear separation between search clients (requesters) and search servers (providers), allowing for flexible deployment models.
2. JSON-RPC Communication: The protocol uses JSON-RPC for message exchange, making it compatible with web technologies and easy to implement across different platforms.
3. Context Management: MCP defines structured methods for maintaining, updating, and leveraging search context across multiple interactions.
4. Tool Definitions: Search capabilities are exposed as standardized tools with well-defined parameters and return values.
5. Streaming Support: The protocol supports streaming results, essential for real-time search where results may arrive progressively.
When integrating MCP with web search, several patterns emerge:
graph LR
Client[MCP Client] --> |MCP Request| Server[MCP Server]
Server --> |API Call| SearchAPI[Search API]
SearchAPI --> |Results| Server
Server --> |MCP Response| Client
In this pattern, the MCP server directly interfaces with one or more search APIs, translating MCP requests into API-specific calls and formatting the results as MCP responses.
graph LR
Client[MCP Client] --> |MCP Request| Federation[MCP Federation Layer]
Federation --> |MCP Request 1| Search1[Search Provider 1]
Federation --> |MCP Request 2| Search2[Search Provider 2]
Federation --> |MCP Request 3| Search3[Search Provider 3]
Search1 --> |MCP Response 1| Federation
Search2 --> |MCP Response 2| Federation
Search3 --> |MCP Response 3| Federation
Federation --> |Aggregated MCP Response| Client
This pattern distributes search queries across multiple MCP-compatible search providers, each potentially specializing in different types of content or search capabilities, while maintaining a unified context.
graph LR
Client[MCP Client] --> |Query + Context| Server[MCP Server]
Server --> |1. Query Analysis| NLP[NLP Service]
NLP --> |Enhanced Query| Server
Server --> |2. Search Execution| Search[Search Engine]
Search --> |Raw Results| Server
Server --> |3. Result Processing| Enhancement[Result Enhancement]
Enhancement --> |Enhanced Results| Server
Server --> |Final Results + Updated Context| Client
In this pattern, the search process is divided into multiple stages, with context being enriched at each step, resulting in progressively more relevant results.
In MCP-based web search, context typically includes:
MCP enhances research workflows by:
MCP-powered search offers advantages for news monitoring:
MCP creates new possibilities for AI-augmented browsing:
Looking ahead, we anticipate MCP evolving to address:
Emerging technologies that will shape the future of MCP search:
1. Neural Search Architectures: Embedding-based search systems optimized for MCP
2. Personalized Search Context: Learning individual user search patterns over time
3. Knowledge Graph Integration: Contextual search enhanced by domain-specific knowledge graphs
4. Cross-Modal Context: Maintaining context across different search modalities
In this exercise, you'll learn how to:
Create a complete application that:
Advanced exercise covering:
By completing this module, you will be able to:
When implementing MCP-based web search solutions, remember these important principles from the MCP specification:
1. User Consent and Control: Users must explicitly consent to and understand all data access and operations. This is particularly important for web search implementations that may access external data sources.
2. Data Privacy: Ensure appropriate handling of search queries and results, especially when they might contain sensitive information. Implement appropriate access controls to protect user data.
3. Tool Safety: Implement proper authorization and validation for search tools, as they represent potential security risks through arbitrary code execution.
Descriptions of tool behavior should be considered untrusted unless obtained from a trusted server.
4. Clear Documentation: Provide clear documentation about the capabilities, limitations, and security considerations of your MCP-based search implementation, following the implementation guidelines from the MCP specification.
5. Robust Consent Flows: Build robust consent and authorization flows that clearly explain what each tool does before authorizing its use, especially for tools that interact with external web resources.
For complete details on MCP security and trust considerations, refer to the official documentation.
> 중요 참고: 아래 코드 예제는 Model Context Protocol(MCP)과 웹 검색 기능의 통합을 보여줍니다. 공식 MCP SDK의 패턴과 구조를 따르지만 교육 목적으로 단순화되어 있습니다.
>
> 이 예제들은 다음을 보여줍니다:
>
> 1. 파이썬 구현: FastMCP 서버 구현으로, 웹 검색 도구를 제공하고 외부 검색 API에 연결합니다.
이 예제는 공식 MCP Python SDK의 패턴을 따라 적절한 수명 주기 관리, 컨텍스트 처리, 도구 구현을 시연합니다.
서버는 프로덕션 배포에서 이전 SSE 전송 방식을 대체한 권장 Streamable HTTP 전송을 사용합니다.
>
> 2. 자바스크립트 구현: 공식 MCP TypeScript SDK의 FastMCP 패턴을 활용한 TypeScript/JavaScript 구현으로, 적절한 도구 정의와 클라이언트 연결을 갖춘 검색 서버를 만듭니다.
최신 권장 세션 관리 및 컨텍스트 보존 패턴을 따릅니다.
>
> 이 예제들은 프로덕션 환경에서는 추가적인 오류 처리, 인증, 특정 API 통합 코드가 필요합니다.
예시로 사용된 검색 API 엔드포인트(https://api.search-service.example/search)는 자리 표시자이며 실제 검색 서비스 엔드포인트로 교체해야 합니다.
>
> 완전한 구현 세부사항과 최신 접근법은 공식 MCP 명세와 SDK 문서를 참고하시기 바랍니다.
MCP는 AI 모델, 애플리케이션, 서비스 간에 컨텍스트를 교환하기 위한 표준화된 방식을 제공합니다. 실시간 웹 검색에서는 일관된 다중 턴 검색 경험을 만드는 데 필수적입니다. 주요 구성 요소는 다음과 같습니다:
1. 클라이언트-서버 아키텍처: MCP는 검색 클라이언트(요청자)와 검색 서버(제공자)를 명확히 분리하여 유연한 배포 모델을 지원합니다.
2. JSON-RPC 통신: 프로토콜은 JSON-RPC를 사용해 메시지를 교환하며, 웹 기술과 호환되고 다양한 플랫폼에서 쉽게 구현할 수 있습니다.
3. 컨텍스트 관리: MCP는 여러 상호작용에 걸쳐 검색 컨텍스트를 유지, 업데이트, 활용하는 구조화된 방법을 정의합니다.
4. 도구 정의: 검색 기능을 명확한 매개변수와 반환값을 가진 표준화된 도구로 노출합니다.
5. 스트리밍 지원: 결과가 점진적으로 도착하는 실시간 검색에 필수적인 스트리밍 결과를 지원합니다.
MCP를 웹 검색에 통합할 때 다음과 같은 패턴이 나타납니다:
graph LR
Client[MCP Client] --> |MCP Request| Server[MCP Server]
Server --> |API Call| SearchAPI[Search API]
SearchAPI --> |Results| Server
Server --> |MCP Response| Client
이 패턴에서는 MCP 서버가 하나 이상의 검색 API와 직접 인터페이스하며, MCP 요청을 API별 호출로 변환하고 결과를 MCP 응답 형식으로 포맷합니다.
graph LR
Client[MCP Client] --> |MCP Request| Federation[MCP Federation Layer]
Federation --> |MCP Request 1| Search1[Search Provider 1]
Federation --> |MCP Request 2| Search2[Search Provider 2]
Federation --> |MCP Request 3| Search3[Search Provider 3]
Search1 --> |MCP Response 1| Federation
Search2 --> |MCP Response 2| Federation
Search3 --> |MCP Response 3| Federation
Federation --> |Aggregated MCP Response| Client
이 패턴은 여러 MCP 호환 검색 제공자에 검색 쿼리를 분산시키며, 각 제공자는 서로 다른 콘텐츠 유형이나 검색 기능에 특화될 수 있고, 통합된 컨텍스트를 유지합니다.
graph LR
Client[MCP Client] --> |Query + Context| Server[MCP Server]
Server --> |1. Query Analysis| NLP[NLP Service]
NLP --> |Enhanced Query| Server
Server --> |2. Search Execution| Search[Search Engine]
Search --> |Raw Results| Server
Server --> |3. Result Processing| Enhancement[Result Enhancement]
Enhancement --> |Enhanced Results| Server
Server --> |Final Results + Updated Context| Client
이 패턴은 검색 프로세스를 여러 단계로 나누고 각 단계에서 컨텍스트를 풍부하게 하여 점진적으로 더 관련성 높은 결과를 도출합니다.
MCP 기반 웹 검색에서 컨텍스트는 일반적으로 다음을 포함합니다:
MCP는 연구 워크플로우를 다음과 같이 향상시킵니다:
MCP 기반 검색은 뉴스 모니터링에 다음과 같은 이점을 제공합니다:
MCP는 AI 보조 브라우징에 새로운 가능성을 만듭니다:
앞으로 MCP는 다음을 다룰 것으로 기대됩니다:
미래의 MCP 검색을 형성할 신기술들:
1. 신경망 검색 아키텍처: MCP에 최적화된 임베딩 기반 검색 시스템
2. 개인화된 검색 컨텍스트: 개별 사용자의 검색 패턴을 시간에 따라 학습
3. 지식 그래프 통합: 도메인별 지식 그래프를 활용한 맥락 기반 검색 강화
4. 교차 모달 컨텍스트: 다양한 검색 모달리티 간 컨텍스트 유지
이 과제에서는 다음을 배우게 됩니다:
다음 기능을 갖춘 완전한 애플리케이션을 만드세요:
고급 과제로 다음 내용을 다룹니다:
이 모듈을 완료하면 다음을 할 수 있습니다:
MCP 기반 웹 검색 솔루션을 구현할 때 MCP 사양에서 제시하는 다음 중요한 원칙을 기억하세요:
1. 사용자 동의 및 통제: 사용자는 모든 데이터 접근 및 작업에 대해 명확히 동의하고 이해해야 합니다. 특히 외부 데이터 소스에 접근하는 웹 검색 구현에서 중요합니다.
2. 데이터 프라이버시: 민감한 정보가 포함될 수 있는 검색 쿼리와 결과를 적절히 처리하고, 사용자 데이터를 보호하기 위한 접근 제어를 구현해야 합니다.
3. 도구 안전성: 검색 도구는 임의 코드 실행을 통해 보안 위험이 될 수 있으므로 적절한 권한 부여와 검증을 수행해야 합니다. 도구 동작 설명은 신뢰할 수 있는 서버에서 제공된 경우가 아니면 신뢰하지 않아야 합니다.
4. 명확한 문서화: MCP 사양의 구현 지침에 따라 MCP 기반 검색 구현의 기능, 한계, 보안 고려사항에 대해 명확한 문서를 제공해야 합니다.
5. 견고한 동의 절차: 외부 웹 리소스와 상호작용하는 도구 사용 전, 각 도구가 수행하는 작업을 명확히 설명하는 견고한 동의 및 권한 부여 절차를 구축해야 합니다.
MCP 보안 및 신뢰 관련 자세한 내용은 공식 문서를 참고하세요.
면책 조항:
이 문서는 AI 번역 서비스 Co-op Translator를 사용하여 번역되었습니다.
정확성을 위해 최선을 다하고 있으나, 자동 번역에는 오류나 부정확한 부분이 있을 수 있음을 유의하시기 바랍니다.
원문은 해당 언어의 원본 문서가 권위 있는 출처로 간주되어야 합니다.
중요한 정보의 경우 전문적인 인간 번역을 권장합니다.
본 번역 사용으로 인해 발생하는 오해나 잘못된 해석에 대해 당사는 책임을 지지 않습니다.