# FRIDAY Tony Stark Demo: Voice Agent with MCP Tools

> SAGAR-TAMANG/friday-tony-stark-demo is a Python reference application that combines a FastMCP server with a LiveKit voice agent. It suits developers who want to study a multi-provider speech and language pipeline, but it requires several API services and two simultaneous processes.

**SAGAR-TAMANG/friday-tony-stark-demo** — Demo of tools of capabilities of Tony Stark.

- Repository: https://github.com/SAGAR-TAMANG/friday-tony-stark-demo
- Website: http://friday.feynmanpi.com/
- Stars: 1,626 · Forks: 439
- Language: Python
- License: not declared
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/sagar-tamang-friday-tony-stark-demo

## FRIDAY's split architecture solves a specific integration problem

FRIDAY is a Tony Stark-inspired assistant demo for developers who want to connect a conversational voice interface to callable tools. Its specific problem is not general speech recognition by itself. It demonstrates how a user can speak to an agent, allow a language model to decide that a tool is needed, call that tool through the Model Context Protocol, and return the result to the spoken conversation.

The project separates this work into two cooperating pieces. The FastMCP server exposes news, web search, system information and utility operations. The LiveKit voice agent handles the real-time interaction path, including microphone input, speech-to-text, the language model, tool access and text-to-speech. This split makes the backend tools reusable by an agent process, but it also creates an operational dependency: both processes must run at the same time.

The intended audience is therefore closer to developers studying agent architecture than end users seeking a packaged assistant. The repository provides Python entry points, provider configuration, tool registration instructions and environment templates. It does not describe a production deployment plan, authentication model for the MCP endpoint, monitoring strategy or rollback procedure.

## The microphone-to-tool request path uses LiveKit, SSE and model providers

The documented data path begins with a microphone and passes through Sarvam Saaras v3 for speech-to-text. The resulting text is sent to Gemini 2.5 Flash by default. The language model can call tools exposed by the FastMCP server, which communicates over SSE at `http://127.0.0.1:8000/sse`. The response is then passed to OpenAI TTS using the `nova` voice and played through a speaker or LiveKit room.

The README names the tool-facing functions `get_world_news`, `open_world_monitor`, `search_web`, `fetch_url`, `get_current_time`, `get_system_info`, `format_json` and `word_count`. The server package is divided into `friday/tools/web.py`, `friday/tools/system.py` and `friday/tools/utils.py`, while prompt templates live under `friday/prompts/` and resources under `friday/resources/`.

This architecture keeps the tool server separate from the voice pipeline. It also means that a successful voice conversation depends on several remote systems. The default path uses LiveKit for the room, Sarvam for speech-to-text, Gemini for the language model and OpenAI for speech output. The repository also exposes alternate provider constants, but changing a constant does not remove the need to supply the corresponding credentials.

## Developer installation follows the documented uv and LiveKit setup

The README requires Python 3.11 or newer, `uv` and a LiveKit Cloud project. The free LiveKit tier is identified as usable. Clone the repository, create the virtual environment and install dependencies with `uv sync`.

```bash
git clone https://github.com/SAGAR-TAMANG/friday-tony-stark-demo.git
cd friday-tony-stark-demo
uv sync
```

This step is expected to create `.venv` and install the packages declared in `pyproject.toml`. The environment file is created from the repository template rather than edited directly.

```bash
cp .env.example .env
```

Fill `.env` with the required credentials before launching either entry point. The required default-path variables are `LIVEKIT_URL`, `LIVEKIT_API_KEY`, `LIVEKIT_API_SECRET`, `SARVAM_API_KEY`, `OPENAI_API_KEY` and `GOOGLE_API_KEY`. The README marks `GROQ_API_KEY`, `DEEPGRAM_API_KEY`, `GOOGLE_APPLICATION_CREDENTIALS`, `SUPABASE_URL` and `SUPABASE_API_KEY` as optional for their listed uses.

For a first developer run, start the MCP server first:

```bash
uv run friday
```

Then start the voice process in a second terminal:

```bash
uv run friday_voice
```

The first command starts FastMCP on port 8000. The second starts the LiveKit agent in dev mode and joins a LiveKit room. The README directs the user to the LiveKit Agents Playground to connect to that room and speak to FRIDAY.

## FRIDAY's two commands have different responsibilities

The command names are easy to confuse because both belong to the same project. `friday` maps to `server:main` and starts the MCP server. `friday_voice` maps to `agent_friday:dev` and starts the LiveKit voice agent. The README explains that the voice entry point automatically injects the `dev` CLI flag.

The MCP server is the component that registers callable tools, prompts and resources. The voice agent builds the speech pipeline and wires the MCP server into that pipeline as a tool source. In practical terms, starting only `friday_voice` does not provide the documented tool backend, while starting only `friday` does not create the microphone conversation experience.

The default SSE address is local, but the README also states that the connection is automatically resolved to the Windows host IP when the voice agent runs inside WSL. That accommodation helps developers move between Windows and WSL, but it does not turn the setup into a network deployment guide. No remote MCP authentication, TLS configuration or service manager instructions are documented in the README.

## Adding a tool requires registering it in the MCP package

FRIDAY offers a direct extension point for developers. The README instructs contributors to create or open a file in `friday/tools/`, define a `register(mcp)` function, decorate each tool with `@mcp.tool()`, and import and call `register(mcp)` from `friday/tools/__init__.py`.

The server is expected to recognize the new tool after it is restarted. This approach is convenient for a small demo, but it couples tool discovery to server startup and requires code changes rather than a documented external tool registry. The README does not describe permissions, input validation, timeouts, retry behavior or production error handling for tools. Developers adding web access or system information should therefore inspect the implementation and decide those policies themselves.

## Provider switching is available through constants in agent_friday.py

The agent file exposes three provider constants that can be edited directly:

```python
STT_PROVIDER = "sarvam"
LLM_PROVIDER = "gemini"
TTS_PROVIDER = "openai"
```

The README lists `"sarvam"` and `"whisper"` for speech-to-text, `"gemini"` and `"openai"` for the language model, and `"openai"` and `"sarvam"` for text-to-speech. This gives the project a provider-adapter shape, but the README does not provide a separate configuration file or command for switching providers. It explicitly instructs developers to open `agent_friday.py` and change constants at the top.

The alternative providers also have different credential requirements. Groq is associated with `GROQ_API_KEY`, Deepgram with `DEEPGRAM_API_KEY`, and Google speech-to-text with `GOOGLE_APPLICATION_CREDENTIALS` or an application-default login route described in `.env.example`. Selecting a provider without its account and key leaves the demo unable to complete that stage of the pipeline.

A real alternative is a single-process assistant built directly around one speech stack and local tool functions. That approach reduces service orchestration and credential setup, but it would not demonstrate FRIDAY's specific MCP boundary, SSE connection or LiveKit tool-source arrangement.

## FRIDAY is a reference demo with substantial external-service and maintenance costs

The strongest limitation is operational rather than conceptual. A developer needs Python 3.11 or newer, `uv`, a LiveKit Cloud project, credentials for the selected providers and two processes kept alive during use. A network interruption or missing API key can prevent a stage of the interaction, while the README does not document fallback behavior for failed speech recognition, language-model requests, TTS requests or MCP calls.

The project is also a demo rather than a documented distribution model. It has no GitHub releases, and the repository's top-level layout contains source files, `pyproject.toml`, `.env.example`, `README.md` and the `friday/` package. The last push was on 2026-07-06, which is recent enough to indicate recent repository activity. The README advertises `.exe` and `.dmg` installers, but there are no GitHub releases to establish a maintained versioning cadence. Upgrade work would therefore depend on changing dependencies in `pyproject.toml` and the environment configuration rather than selecting a documented release version.

The README states an MIT license. That is the stated licensing information, but it does not replace review of the full repository files and dependency licenses before redistribution or commercial use. The project is most appropriate as a learning base for MCP tool wiring and voice-agent composition, not as a self-contained assistant with predictable operational guarantees.

## Conclusion

Adopt this repository as a reference implementation for experimenting with MCP-backed voice tools, not as a ready-made production assistant. Engineers who need a single-process, offline or provider-independent voice application should choose a different design. Verify first that your required API accounts, credentials, Python version, LiveKit room and local SSE connection are available.

## FAQ

### What does FRIDAY Tony Stark Demo do?

It is a Tony Stark-inspired voice assistant demo with a FastMCP server and a LiveKit voice agent. The server exposes tools such as news and web search, while the agent listens, calls the language model, retrieves tool results and speaks responses.

### How do I run the FRIDAY Tony Stark Demo?

Install dependencies with `uv sync`, copy `.env.example` to `.env`, and fill in the required API keys. Start `uv run friday` first, then run `uv run friday_voice` in a second terminal.

### Can I change the speech and language providers in FRIDAY?

The README says to edit provider constants at the top of `agent_friday.py`. It lists Sarvam or Whisper for speech-to-text, Gemini or OpenAI for the language model, and OpenAI or Sarvam for text-to-speech.

## Sources

- [Issues](https://github.com/SAGAR-TAMANG/friday-tony-stark-demo/issues)
- [Project website](http://friday.feynmanpi.com/)
- [README](https://github.com/SAGAR-TAMANG/friday-tony-stark-demo/blob/main/README.md)
- [SAGAR-TAMANG/friday-tony-stark-demo on GitHub](https://github.com/SAGAR-TAMANG/friday-tony-stark-demo)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/sagar-tamang-friday-tony-stark-demo