How to Add Function-Calling Bots with MCP

# server.py
from fastmcp import FastMCP
import httpx

mcp = FastMCP("Stream MCP Server")

# Define a tool that can be used by your MCP Client
@mcp.tool()
def get_forecast(city: str) -> str:
    """Return today's weather for <city>."""
    data = httpx.get(f"https://wttr.in/{city}?format=%C+%t").text
    return data.strip()

if __name__ == "__main__":
    mcp.run()

# agent.py
import json, re, os, logging, openai, fastmcp

openai.api_key = os.environ["OPENAI_API_KEY"]
logging.basicConfig(level=logging.INFO)

# The system prompt that will be passed in to the LLM
SYSTEM = """
You are a helpful assistant. When the user needs real-world weather data, call the get_forecast tool.
If you call a tool, use tool_name["arg":"value"]  on a single line.
You can chain up to 3 tool calls.
"""

def _chat(messages):
    resp = openai.chat.completions.create(model="gpt-4o", messages=messages)
    return resp.choices[0].message.content

async def chat_with_tools(prompt: str, client: fastmcp.Client) -> str:
    tools = await client.list_tools()
    tool_names = {t.name for t in tools}
    history = [
        {"role": "system", "content": SYSTEM},
        {"role": "user", "content": prompt},
    ]

    while True:
        reply = _chat(history)
        m = re.match(r"^(\w+)\[(.*)\]$", reply.strip())

        if not (m and m.group(1) in tool_names):
            return reply

        name, args_json = m.groups()
        args = json.loads(f"{{{args_json}}}")
        result = await client.call_tool(name, args)
        history.append({"role": "assistant", "content": str(result.data)})

import os, uuid, asyncio, logging, webbrowser
from urllib.parse import urlencode
from dotenv import load_dotenv

from getstream.stream import Stream
from getstream.models import UserRequest
from getstream.video import rtc
from getstream.video.rtc import audio_track
from getstream.video.rtc.track_util import PcmData
from getstream.plugins.deepgram.stt import DeepgramSTT
from getstream.plugins.elevenlabs.tts import ElevenLabsTTS

from agent import chat_with_tools
import fastmcp

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")

load_dotenv()

CLIENT = Stream.from_env()

def _create_user(user_id: str, name: str):
    CLIENT.upsert_users(UserRequest(id=user_id, name=name))


def _open_browser(call_id: str, token: str):
    base = f"{os.getenv('EXAMPLE_BASE_URL')}/join/"
    params = {"api_key": CLIENT.api_key, "token": token, "skip_lobby": "true"}
    url = f"{base}{call_id}?{urlencode(params)}"
    webbrowser.open(url)

async def _run_bot(call, bot_id):
    stt = DeepgramSTT()
    tts = ElevenLabsTTS()
    track = audio_track.AudioStreamTrack(framerate=16000)
    tts.set_output_track(track)

    async with await rtc.join(call, bot_id) as conn:
        await conn.add_tracks(audio=track)
        async with fastmcp.Client("server.py") as mcp_client:

            @conn.on("audio")
            async def on_audio(pcm: PcmData, user):
                await stt.process_audio(pcm, user)

            @stt.on("transcript")
            async def on_transcript(text, user, meta):
                if not meta.get("is_final", False):
                    return
                answer = await chat_with_tools(text, mcp_client)
                if answer:
                    await tts.send(answer)

            await conn.wait()

async def main():
    call_id = str(uuid.uuid4())
    human_id = f"user-{uuid.uuid4()}"
    bot_id = f"mcp-bot-{uuid.uuid4()}"

    _create_user(human_id, "Human")
    _create_user(bot_id, "MCP Bot")

    token = CLIENT.create_token(human_id, expiration=3600)
    call = CLIENT.video.call("default", call_id)
    call.get_or_create(data={"created_by_id": bot_id})
    _open_browser(call_id, token)

    try:
        await _run_bot(call, bot_id)
    finally:
        CLIENT.delete_users([human_id, bot_id])


if __name__ == "__main__":
    asyncio.run(main())