Mistral Agents API 및 MCP 활용: 얼마나 좋을까?

인공지능(AI)은 단순히 텍스트를 생성하거나 이미지를 인식하는 것을 넘어 빠르게 발전하고 있습니다. 다음 단계는 의미 있는 방식으로 행동하고, 문제를 해결하며, 세상과 상호작용할 수 있는 AI입니다. 이 분야의 저명한 기업인 Mistral AI는 Mistral Agents API를 통해 이러한 방향으로 중요한 발걸음을 내디뎠습니다. 이 강력한 툴킷을 통해 개발자는 기존 언어 모델보다 훨씬 더 많은 작업을 수행할 수 있는 정교한 AI 에이전트를 구축할 수 있습니다.

본질적으로 Agents API는 언어를 이해하고 생성하는 데는 뛰어나지만, 행동을 수행하거나, 과거 상호작용을 일관되게 기억하거나, 외부 도구를 효과적으로 사용하는 데 어려움을 겪는 표준 AI 모델의 한계를 극복하도록 설계되었습니다. Mistral Agents API는 강력한 언어 모델에 다양한 도구에 대한 내장 커넥터, 대화 전반에 걸친 영구 메모리, 복잡한 작업을 조율하는 기능과 같은 기능을 갖추게 함으로써 이러한 문제를 해결합니다.

이것을 책에 대해서만 이야기할 수 있는 매우 박식한 사서에서 정보를 얻을 뿐만 아니라 실험을 수행하고, 보고서를 작성하며, 서로 협력할 수 있는 전문가 연구원 팀으로 업그레이드하는 것에 비유해 보세요. 이 새로운 API는 워크플로우를 자동화하고, 복잡한 의사결정을 지원하며, 진정한 대화형 경험을 제공할 수 있는 엔터프라이즈급 AI 애플리케이션을 만드는 기반이 됩니다.

💡

아름다운 API 문서를 생성하는 훌륭한 API 테스트 도구를 원하십니까?

최대한의 생산성으로 개발팀이 함께 작업할 수 있는 통합된 올인원 플랫폼을 원하십니까?

Apidog는 여러분의 모든 요구사항을 충족하며, 훨씬 더 저렴한 가격으로 Postman을 대체합니다!

버튼

Mistral 에이전트가 그토록 뛰어난 이유는 무엇일까요?

기존 언어 모델은 텍스트 생성에 능숙하지만, 확장된 상호작용 전반에 걸쳐 행동을 실행하거나 정보를 기억하는 데는 종종 부족합니다. Mistral Agents API는 Mistral의 최첨단 언어 모델과 에이전트 워크플로우를 위해 설계된 강력한 기능 모음을 결합하여 이러한 한계를 직접적으로 해결합니다.

핵심 기능:

본질적으로 Agents API는 다음을 제공합니다:

내장 커넥터: 에이전트가 필요에 따라 호출할 수 있는 미리 배포된 도구입니다. 다음을 포함합니다:
코드 실행: 에이전트가 보안 샌드박스에서 Python 코드를 실행할 수 있도록 하여 계산, 데이터 분석 및 과학 컴퓨팅에 유용합니다.
웹 검색: 에이전트에게 인터넷의 최신 정보에 대한 액세스 권한을 부여하여 응답 정확도와 관련성을 크게 향상시킵니다. 예를 들어, SimpleQA 벤치마크에서 웹 검색을 사용한 Mistral Large는 75%의 점수를 달성했는데, 이는 사용하지 않았을 때의 23%보다 엄청나게 향상된 수치입니다.
이미지 생성: Black Forest Lab FLUX1.1 [pro] Ultra와 같은 모델을 활용하여 에이전트가 교육 보조 도구부터 마케팅 그래픽에 이르기까지 다양한 애플리케이션을 위한 이미지를 생성할 수 있습니다.
문서 라이브러리: 에이전트가 Mistral Cloud의 문서에 액세스하고 활용할 수 있도록 하여 통합된 RAG(Retrieval Augmented Generation)를 강화하여 지식 기반을 향상시킵니다.
MCP 도구: 파트 3에서 자세히 살펴볼 Model Context Protocol을 통해 외부 시스템과의 원활한 통합을 촉진합니다.
영구 메모리: 에이전트는 대화 전반에 걸쳐 컨텍스트를 유지하여 보다 일관되고 의미 있는 장기 상호작용을 가능하게 합니다.
에이전트 오케스트레이션: API를 통해 여러 에이전트를 조정할 수 있으며, 각 에이전트는 잠재적으로 서로 다른 작업에 특화되어 복잡한 문제를 협력적으로 해결할 수 있습니다.

이 API는 Chat Completion API의 단순한 확장이 아니라, 에이전트 사용 사례 구현을 단순화하기 위해 특별히 설계된 전용 프레임워크입니다. 기업이 AI를 보다 실용적이고 영향력 있으며 행동 지향적인 방식으로 배포할 수 있도록 하는 엔터프라이즈급 에이전트 플랫폼의 기반이 되도록 설계되었습니다.

실제 적용 사례: Mistral 에이전트의 활용

Agents API의 다재다능함은 다양한 혁신적인 애플리케이션을 통해 잘 나타납니다:

GitHub 코딩 도우미: 전체 리포지토리 권한으로 소프트웨어 개발 작업을 자동화하기 위해 GitHub와 상호작용하는 개발자 에이전트(DevStral 기반)를 감독하는 에이전트 워크플로우입니다.
Linear 티켓 도우미: 멀티 서버 MCP 아키텍처를 사용하여 통화 기록을 제품 요구사항 문서(PRD)로 변환하고, 이를 실행 가능한 Linear 이슈로 만들고, 이후 프로젝트 결과물을 추적하는 지능형 도우미입니다.
재무 분석가: 여러 MCP 서버를 조율하여 재무 지표를 수집하고, 인사이트를 취합하며, 결과를 안전하게 보관하는 자문 에이전트로, 복잡한 데이터 집계 및 분석을 보여줍니다.
여행 도우미: 사용자가 여행을 계획하고, 숙박 시설을 예약하며, 다양한 여행 관련 요구사항을 관리하도록 돕는 포괄적인 AI 도구입니다.
영양 도우미: 사용자가 목표를 설정하고, 식사를 기록하고, 개인화된 음식 제안을 받고, 일일 진행 상황을 추적하며, 영양 목표에 맞는 레스토랑을 찾도록 돕는 AI 기반 식단 도우미입니다.

메모리, 컨텍스트 및 상태 유지 대화

Agents API의 핵심은 강력한 대화 관리 시스템입니다. 이는 상호작용이 상태를 유지하도록 보장하며, 즉 시간이 지나도 컨텍스트가 유지됩니다. 개발자는 두 가지 주요 방식으로 대화를 시작할 수 있습니다:

에이전트 사용: agent_id를 지정하여 특정 에이전트의 사전 구성된 기능, 도구 및 지침을 활용합니다.
직접 액세스: 모델 및 완료 매개변수를 직접 지정하여 사전 정의된 에이전트 없이 내장 커넥터에 빠르게 액세스하여 대화를 시작할 수 있습니다.

각 대화는 '대화 항목'을 통해 구조화된 기록을 유지하여 컨텍스트가 꼼꼼하게 보존되도록 합니다. 이러한 상태 유지를 통해 개발자는 과거 대화를 보고, 모든 상호작용을 원활하게 계속하거나, 기록의 어느 지점에서든 새로운 대화 경로를 시작하기 위해 분기할 수도 있습니다. 또한 API는 스트리밍 출력을 지원하여 실시간 업데이트 및 동적 상호작용을 가능하게 합니다.

에이전트 오케스트레이션: 협업의 힘

Agents API의 진정한 차별화 능력은 여러 에이전트를 조율하는 능력에서 나옵니다. 이는 단일의 거대한 AI에 관한 것이 아니라, 전문화된 에이전트들이 협력하여 작동하는 교향곡에 관한 것입니다. 동적 오케스트레이션을 통해 필요에 따라 대화에 에이전트를 추가하거나 제거할 수 있으며, 각 에이전트는 복잡한 문제의 다양한 측면을 해결하기 위해 고유한 기술을 기여합니다.

핸드오프가 있는 에이전트 워크플로우를 구축하려면:

에이전트 생성: 각 에이전트의 역할에 맞게 특정 도구, 모델 및 지침을 갖춘 필요한 모든 에이전트를 정의하고 생성합니다.
핸드오프 정의: 어떤 에이전트가 다른 에이전트에게 작업을 위임할 수 있는지 지정합니다. 예를 들어, 주요 고객 서비스 에이전트는 기술 문의를 전문적인 문제 해결 에이전트에게 또는 청구 문의를 재무 에이전트에게 핸드오프할 수 있습니다.

이러한 핸드오프는 원활한 일련의 작업을 가능하게 합니다. 단일 사용자 요청은 여러 에이전트에 걸쳐 일련의 작업을 트리거할 수 있으며, 각 에이전트는 지정된 부분을 자율적으로 처리합니다. 이러한 협업 접근 방식은 정교한 실제 애플리케이션의 문제 해결에서 전례 없는 효율성과 효과를 제공합니다.

Mistral Agents API의 기본 사용법

Mistral Agents API의 기능을 이해했으니, 이제 이 API와 상호작용하는 방법을 살펴보겠습니다. 이 API는 세 가지 새로운 주요 객체를 소개합니다:

에이전트: 모델의 기능을 향상시키는 구성입니다. 에이전트 정의에는 사용할 모델, 액세스할 수 있는 도구, 시스템 지침(프롬프트), 기본 완료 매개변수와 같은 미리 선택된 값이 포함됩니다.
대화: 어시스턴트와의 상호작용 및 과거 이벤트 기록을 나타내는 객체입니다. 사용자 메시지, 어시스턴트 응답 및 도구 실행 기록이 포함됩니다.
항목: 항목은 사용 또는 어시스턴트가 생성한 대화 내의 개별 작업 또는 이벤트입니다. 이벤트를 설명하는 데 더 세밀한 제어를 허용하여 상호작용을 표현하는 유연하고 표현적인 방법을 제공합니다.

특히, 공식적인 '에이전트' 객체를 먼저 명시적으로 생성하고 참조하지 않고도 상태 유지 대화 및 내장 커넥터와 같은 많은 기능을 활용할 수 있습니다. 이는 더 간단한 사용 사례에 유연성을 제공합니다.

에이전트 생성

특정 에이전트를 정의하려면 여러 매개변수를 지정하여 API에 요청합니다:

model: 기본 Mistral 모델(예: mistral-medium-latest).
name: 에이전트에 대한 설명적인 이름입니다.
description: 에이전트의 목적 또는 수행하도록 설계된 작업에 대한 간략한 설명입니다.
instructions (선택 사항): 에이전트의 행동 및 응답을 안내하는 시스템 프롬프트입니다.
tools (선택 사항): 에이전트가 사용할 수 있는 도구 목록입니다. 도구 유형은 다음과 같습니다:
function: 사용자 정의 도구로, 채팅 완료의 표준 함수 호출과 유사합니다.
web_search / web_search_premium: 내장 웹 검색 도구입니다.
code_interpreter: 코드 실행을 위한 내장 도구입니다.
image_generation: 이미지 생성을 위한 내장 도구입니다.
completion_args (선택 사항): 온도, top_p 등과 같은 표준 채팅 완료 샘플러 인수입니다.

다음은 간단한 에이전트를 생성하는 cURL 요청 예시입니다:

curl --location "https://api.mistral.ai/v1/agents" \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
         "model": "mistral-medium-latest",
         "name": "Simple Agent",
         "description": "A simple Agent with persistent state."
     }'

에이전트 업데이트

에이전트는 생성 후 업데이트할 수 있습니다. 인수는 생성 시와 동일합니다. 이 작업은 업데이트된 설정으로 새 에이전트 객체를 생성하며, 에이전트의 버전 관리를 효과적으로 허용합니다.

curl --location "https://api.mistral.ai/v1/agents/<agent_id>" \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
         "completion_args": {
           "temperature": 0.3,
           "top_p": 0.95
         },
         "description": "An edited simple agent."
     }'

대화 관리

에이전트가 생성되면(또는 직접 액세스를 사용하는 경우) 대화를 시작할 수 있습니다.

대화 시작:
다음 정보를 제공해야 합니다:

agent_id: 에이전트의 ID(사전 정의된 에이전트를 사용하는 경우).
inputs: 초기 메시지로, 간단한 문자열 또는 메시지 객체 목록일 수 있습니다.
이 요청은 conversation_id를 반환합니다.

예시 (간단한 문자열 입력):

curl --location "https://api.mistral.ai/v1/conversations" \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
         "inputs": "Who is Albert Einstein?",
         "stream": false,
         "agent_id": "<agent_id>"
     }'

대화 계속:
기존 대화에 추가하려면:

conversation_id: 계속할 대화의 ID.
inputs: 다음 메시지 또는 응답(문자열 또는 메시지 목록).
각 계속은 상태가 저장되면 새 conversation_id를 제공합니다. store=False로 설정하여 클라우드 저장소를 사용하지 않도록 선택할 수 있습니다. handoff_execution 매개변수는 에이전트 핸드오프가 관리되는 방식을 제어합니다: server(기본값, Mistral의 클라우드에서 처리) 또는 client(응답이 핸드오프를 관리하기 위해 사용자에게 반환됨).

예시:

curl --location "https://api.mistral.ai/v1/conversations/<conv_id>" \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
         "inputs": "Translate to French.",
         "stream": false,
         "store": true,
         "handoff_execution": "server"
     }'

출력 스트리밍

실시간 상호작용의 경우, stream: true로 설정하고 Accept 헤더가 text/event-stream인지 확인하여 대화 시작 및 계속 모두 스트리밍할 수 있습니다.

curl --location "https://api.mistral.ai/v1/conversations" \
     --header 'Content-Type: application/json' \
     --header 'Accept: text/event-stream' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
         "inputs": "Who is Albert Einstein?",
         "stream": true,
         "agent_id": "ag_06811008e6e07cb48000fd3f133e1771"
     }'

스트리밍할 때 응답의 진행 상황과 내용을 나타내는 다양한 이벤트 유형을 수신하게 됩니다. 예를 들어 다음과 같습니다:

conversation.response.started: 대화 응답의 시작을 표시합니다.
message.output.delta: 모델 응답의 콘텐츠(토큰) 청크입니다.
tool.execution.started / tool.execution.done: 도구 실행의 라이프사이클을 나타냅니다.
agent.handoff.started / agent.handoff.done: 에이전트 핸드오프의 시작과 끝을 알립니다.

이러한 기본 작업은 Mistral 에이전트로 동적 및 대화형 애플리케이션을 구축하기 위한 기반을 형성합니다.

Mistral Agents API와 Model Context Protocol (MCP) 통합하기

내장 커넥터가 상당한 기능을 제공하지만, Mistral 에이전트의 진정한 확장성은 Model Context Protocol(MCP)과 결합될 때 빛을 발합니다.

MCP란 무엇인가요?

Model Context Protocol(MCP)은 AI 모델을 다양한 외부 데이터 소스, 도구 및 API와 통합하는 프로세스를 간소화하기 위해 설계된 개방형 표준입니다. AI 시스템이 실제 컨텍스트 정보를 효율적으로 액세스하고 활용할 수 있도록 표준화되고 안전한 인터페이스를 제공합니다. 수많은 맞춤형 통합을 구축하고 유지 관리하는 대신, MCP는 AI 모델이 실시간 데이터 및 시스템에 연결하는 통합된 방법을 제공하여 더 관련성 있고 정확하며 강력한 응답을 제공합니다. 자세한 내용은 공식 Model Context Protocol 문서를 참조하십시오.

Mistral의 Python SDK는 에이전트와 MCP 클라이언트를 연결하기 위한 원활한 통합 메커니즘을 제공합니다. 이를 통해 에이전트는 로컬 도구, 타사 API 또는 독점 엔터프라이즈 시스템이든 관계없이 MCP 인터페이스를 노출하는 모든 서비스 또는 데이터 소스와 상호작용할 수 있습니다.

Mistral 에이전트와 함께 MCP를 사용하는 세 가지 일반적인 시나리오를 살펴보겠습니다: 로컬 MCP 서버, 인증 없는 원격 MCP 서버, 인증 있는 원격 MCP 서버. 모든 예시는 비동기 Python 코드를 활용합니다.

시나리오 1: 로컬 MCP 서버 사용

Mistral 에이전트가 상호작용하기를 원하는 로컬 스크립트 또는 서비스(예: 사용자 정의 날씨 정보 제공자)가 있다고 상상해 보세요.

단계 1: Mistral 클라이언트 초기화 및 설정
mistralai 및 mcp에서 필요한 모듈을 가져옵니다. 여기에는 Mistral, RunContext, StdioServerParameters(로컬 프로세스 기반 MCP 서버용) 및 MCPClientSTDIO가 포함됩니다.

import asyncio
import os
from pathlib import Path
from mistralai import Mistral
from mistralai.extra.run.context import RunContext
from mcp import StdioServerParameters
from mistralai.extra.mcp.stdio import MCPClientSTDIO
from mistralai.types import BaseModel

cwd = Path(__file__).parent
MODEL = "mistral-medium-latest" # Or your preferred model

async def main_local_mcp():
    api_key = os.environ["MISTRAL_API_KEY"]
    client = Mistral(api_key=api_key)

    # Define parameters for the local MCP server (e.g., running a Python script)
    server_params = StdioServerParameters(
        command="python",
        args=[str((cwd / "mcp_servers/stdio_server.py").resolve())], # Path to your MCP server script
        env=None,
    )

    # Create an agent
    weather_agent = client.beta.agents.create(
        model=MODEL,
        name="Local Weather Teller",
        instructions="You can tell the weather using a local MCP tool.",
        description="Fetches weather from a local source.",
    )

    # Define expected output format (optional, but good for structured data)
    class WeatherResult(BaseModel):
        user: str
        location: str
        temperature: float

    # Create a Run Context
    async with RunContext(
        agent_id=weather_agent.id,
        output_format=WeatherResult, # Optional: For structured output
        continue_on_fn_error=True,
    ) as run_ctx:
        # Create and register MCP client
        mcp_client = MCPClientSTDIO(stdio_params=server_params)
        await run_ctx.register_mcp_client(mcp_client=mcp_client)

        # Example of registering a local Python function as a tool
        import random
        @run_ctx.register_func
        def get_location(name: str) -> str:
            """Function to get a random location for a user."""
            return random.choice(["New York", "London", "Paris"])

        # Run the agent
        run_result = await client.beta.conversations.run_async(
            run_ctx=run_ctx,
            inputs="Tell me the weather in John's location currently.",
        )

        print("Local MCP - All run entries:")
        for entry in run_result.output_entries:
            print(f"{entry}\n")
        if run_result.output_as_model:
            print(f"Local MCP - Final model output: {run_result.output_as_model}")
        else:
            print(f"Local MCP - Final text output: {run_result.output_as_text}")

# if __name__ == "__main__":
#     asyncio.run(main_local_mcp())

이 설정에서 stdio_server.py는 stdin/stdout을 통해 통신하는 MCP 서버 로직을 구현하는 스크립트가 됩니다. RunContext는 상호작용을 관리하며, register_mcp_client는 로컬 MCP 서버를 에이전트가 사용할 수 있는 도구로 만듭니다. `@run_ctx.register_func`를 사용하여 로컬 Python 함수를 직접 등록할 수도 있습니다.

로컬 MCP 서버를 사용한 스트리밍:
스트리밍하려면 client.beta.conversations.run_stream_async를 사용하고 이벤트가 도착하는 대로 처리합니다:

    # Inside RunContext, after MCP client registration
    # events = await client.beta.conversations.run_stream_async(
    #     run_ctx=run_ctx,
    #     inputs="Tell me the weather in John's location currently, stream style.",
    # )
    # streamed_run_result = None
    # async for event in events:
    #     if isinstance(event, RunResult): # Assuming RunResult is defined or imported
    #         streamed_run_result = event
    #     else:
    #         print(f"Stream event: {event}")
    # if streamed_run_result:
    #     # Process streamed_run_result
    #     pass

시나리오 2: 인증 없는 원격 MCP 서버 사용

많은 공개 또는 내부 서비스는 인증 없이 HTTP/SSE를 통해 MCP 인터페이스를 노출할 수 있습니다.

from mistralai.extra.mcp.sse import MCPClientSSE, SSEServerParams

async def main_remote_no_auth_mcp():
    api_key = os.environ["MISTRAL_API_KEY"]
    client = Mistral(api_key=api_key)

    # Define the URL for the remote MCP server (e.g., Semgrep's public MCP)
    server_url = "https://mcp.semgrep.ai/sse"
    mcp_client = MCPClientSSE(sse_params=SSEServerParams(url=server_url, timeout=100))

    async with RunContext(
        model=MODEL, # Can use agent_id too if an agent is pre-created
    ) as run_ctx:
        await run_ctx.register_mcp_client(mcp_client=mcp_client)

        run_result = await client.beta.conversations.run_async(
            run_ctx=run_ctx,
            inputs="Can you write a hello_world.py file and then check it for security vulnerabilities using available tools?",
        )

        print("Remote No-Auth MCP - All run entries:")
        for entry in run_result.output_entries:
            print(f"{entry}\n")
        print(f"Remote No-Auth MCP - Final Response: {run_result.output_as_text}")

# if __name__ == "__main__":
#     asyncio.run(main_remote_no_auth_mcp())

여기서는 MCPClientSSE가 SSEServerParams와 함께 원격 URL을 가리키도록 사용됩니다. 그러면 에이전트는 이 원격 MCP 서버가 제공하는 도구를 활용할 수 있습니다. 스트리밍은 run_stream_async를 사용하여 로컬 MCP 예시와 동일한 패턴을 따릅니다.

시나리오 3: 인증(OAuth) 있는 원격 MCP 서버 사용

OAuth2 인증이 필요한 서비스(Linear, Jira 등)의 경우, 인증 흐름을 처리하기 위해 몇 가지 추가 단계가 필요합니다.

from http.server import BaseHTTPRequestHandler, HTTPServer
import threading
import webbrowser
from mistralai.extra.mcp.auth import build_oauth_params

CALLBACK_PORT = 16010 # Ensure this port is free

# Callback server setup (simplified from source)
def run_callback_server_util(callback_func, auth_response_dict):
    class OAuthCallbackHandler(BaseHTTPRequestHandler):
        def do_GET(self):
            if "/callback" in self.path or "/oauth/callback" in self.path: # More robust check
                auth_response_dict["url"] = self.path
                self.send_response(200)
                self.send_header("Content-type", "text/html")
                self.end_headers()
                self.wfile.write(b"<html><body>Authentication successful. You may close this window.</body></html>")
                callback_func() # Signal completion
                threading.Thread(target=self.server.shutdown).start()
            else:
                self.send_response(404)
                self.end_headers()

    server_address = ("localhost", CALLBACK_PORT)
    httpd = HTTPServer(server_address, OAuthCallbackHandler)
    threading.Thread(target=httpd.serve_forever, daemon=True).start() # Use daemon thread
    redirect_url = f"http://localhost:{CALLBACK_PORT}/oauth/callback"
    return httpd, redirect_url

async def main_remote_auth_mcp():
    api_key = os.environ["MISTRAL_API_KEY"]
    client = Mistral(api_key=api_key)

    server_url = "https://mcp.linear.app/sse" # Example: Linear MCP
    mcp_client_auth = MCPClientSSE(sse_params=SSEServerParams(url=server_url))

    callback_event = asyncio.Event()
    event_loop = asyncio.get_event_loop()
    auth_response_holder = {"url": ""}

    if await mcp_client_auth.requires_auth():
        httpd, redirect_url = run_callback_server_util(
            lambda: event_loop.call_soon_threadsafe(callback_event.set),
            auth_response_holder
        )
        try:
            oauth_params = await build_oauth_params(mcp_client_auth.base_url, redirect_url=redirect_url)
            mcp_client_auth.set_oauth_params(oauth_params=oauth_params)
            login_url, state = await mcp_client_auth.get_auth_url_and_state(redirect_url)

            print(f"Please go to this URL and authorize: {login_url}")
            webbrowser.open(login_url, new=2)
            await callback_event.wait() # Wait for OAuth callback

            token = await mcp_client_auth.get_token_from_auth_response(
                auth_response_holder["url"], redirect_url=redirect_url, state=state
            )
            mcp_client_auth.set_auth_token(token)
            print("Authentication successful.")
        except Exception as e:
            print(f"Error during authentication: {e}")
            return # Exit if auth fails
        finally:
            if 'httpd' in locals() and httpd:
                httpd.shutdown()
                httpd.server_close()
    
    async with RunContext(model=MODEL) as run_ctx: # Or agent_id
        await run_ctx.register_mcp_client(mcp_client=mcp_client_auth)

        run_result = await client.beta.conversations.run_async(
            run_ctx=run_ctx,
            inputs="Tell me which projects do I have in my Linear workspace?",
        )
        print(f"Remote Auth MCP - Final Response: {run_result.output_as_text}")

# if __name__ == "__main__":
#     asyncio.run(main_remote_auth_mcp())

여기에는 OAuth 리다이렉트를 포착하기 위한 로컬 HTTP 서버 설정, 제공업체의 인증 페이지를 통한 사용자 안내, 수신된 코드를 액세스 토큰으로 교환, 그리고 이 토큰으로 MCPClientSSE 구성이 포함됩니다. 인증되면 에이전트는 보호된 MCP 서비스와 상호작용할 수 있습니다. 스트리밍은 다시 설정된 패턴을 따릅니다.

결론: 미래는 에이전트 기반이며 상호 연결됩니다

Mistral Agents API는 특히 Model Context Protocol로 강화될 때 차세대 AI 애플리케이션 구축을 위한 강력하고 유연한 플랫폼을 제공합니다. 에이전트가 추론하고 통신할 뿐만 아니라 방대한 도구, 데이터 소스 및 서비스 생태계와 상호작용할 수 있도록 함으로써 개발자는 복잡한 실제 문제를 해결할 수 있는 진정한 지능형 시스템을 만들 수 있습니다. 복잡한 워크플로우를 자동화하든, 심층적으로 컨텍스트화된 지원을 제공하든, 인간-AI 협업의 새로운 형태를 개척하든, Mistral Agents와 MCP의 조합은 이 흥미로운 미래를 위한 기초 툴킷을 제공합니다. MCP 표준이 더 널리 채택됨에 따라 상호 연결되고 매우 유능한 AI 에이전트를 만들 잠재력은 계속 커질 것입니다.

💡

버튼