Julian KisselMost teams accumulate audio. Meeting recordings, sales calls, interview tapes, podcast episodes, internal trainings – files that nominally contain the company's collective memory but practically live in folders nobody opens twice. Search the audio? Sure, by filename, if you remember it.
In 2026, this is solvable. Audio gets transcribed cheaply enough (under €0.30/hour) that it makes sense to transcribe everything by default. AI agents read text fluently. The Model Context Protocol (MCP) gives those agents structured access to external systems. Stitch the three together and you get a setup where Claude or ChatGPT can answer questions like "what did we tell the Hamburg client about the rollout schedule" with citations from the actual recordings.
This article walks through the architecture: what to record, how to transcribe, how to expose it to an agent, and what privacy decisions matter.
The shape of the problem
Audio is hostile to retrieval. You cannot grep an MP3, you cannot link to a phrase in a meeting, you cannot ask a chatbot about a sales call from three months ago. The information is there, encoded in a waveform, but every consumer of it (humans, tools, agents) has to listen linearly.
Transcription flips this. A transcript is text. Text indexes, searches, summarizes, embeds, links. A 60-minute meeting becomes a queryable artifact instead of an unopenable file.
But "transcription" alone is not the goal. The goal is: agents that can act on what was said. That requires three layers:
- Transcribe – convert audio to time-stamped, speaker-labeled text.
- Store – keep transcripts queryable indefinitely (or as long as compliance allows).
- Expose – give agents a structured way to search and read those transcripts.
The first two are well-trodden. The third is what MCP enables.
A primer on MCP
The Model Context Protocol, introduced by Anthropic in late 2024 and now broadly adopted, is a standard way for LLMs to talk to external systems. An MCP server exposes a set of tools (read this resource, search this index, run this query) and an agent's runtime calls those tools mid-conversation.
The win over earlier "function calling" approaches is interoperability. An MCP server you build once works with Claude, ChatGPT (via the Claude-compatible bridges), Cursor, Zed, and any other agent that speaks MCP. You stop building bespoke tool integrations per agent.
For transcription, MCP is a natural fit. The agent says "search transcripts for X," gets back matching segments with speakers and timestamps, and weaves that into a response. The user does not need to know which meeting the answer came from until they ask for citations.
Architecture: agent-readable audio archive
A working setup looks like this:
[Recording sources] [DeepScript] [Agent]
Zoom/Meet recordings ─► ┌────────────────────┐ MCP query ┌─────────────┐
Phone calls ─► │ Transcribe │ ◄──────────── │ Claude │
Interviews ─► │ Speaker label │ │ (or other) │
Field recordings ─► │ Store + index │ ─ JSON ──────► │ │
└────────────────────┘ └─────────────┘
│ │
└─ permanent retention via Pro plan ─┘Three components:
Source-to-DeepScript. Whatever produces audio (Zoom recording bot, call recorder, hand-held device) drops files into DeepScript via the REST API. A small uploader script can watch a folder and POST new files.
DeepScript transcription + storage. Audio is processed, transcripts are stored. The default retention is 30 days for audio; the Pro plan extends this to permanent retention for transcripts and audio. For an "agent-readable archive" use case, you almost always want Pro.
MCP exposure. DeepScript runs a hosted MCP server at https://mcp.deepscript.com and exposes three tools:
search_transcripts– full-text search across the library, returns the top hits with snippet, transcript id and dateget_transcript– the full text plus word-level metadata for one transcriptionlist_recent– the last N transcriptions
The agent only sees what its credentials allow, and the credential is a normal ds_live_ API key – the same one the REST API uses. There is no separate token type to manage.
Setting it up: the 15-minute version
Walking through the actual setup with DeepScript:
1. Subscribe to Pro on the directory you want agent-accessible
Permanent retention of transcripts requires the Pro plan (€22/month per directory). You can keep other directories on the default 30-day retention; pricing is per-directory, not blanket.
This runs through billing in the app, not through the public API: Billing → Pro activates it and takes you through Stripe Checkout once. Subsequent directories are added without another checkout.
2. Use your API key as the MCP credential
There is no separate token type. The MCP server authenticates with the same ds_live_ API key as the REST API, which you generate under Settings → API Keys. Treat it like a password: it grants read access to the transcripts in its scope.
3. Add the server to Claude Desktop
The MCP server is hosted, so there is nothing to install. In Claude Desktop's claude_desktop_config.json:
{
"mcpServers": {
"deepscript": {
"url": "https://mcp.deepscript.com",
"headers": {
"Authorization": "Bearer ds_live_xxx"
}
}
}
}Cursor and Zed use the same URL with their own config shape; the wiring for both is on the MCP integration page.
Restart Claude Desktop and the new tool surface appears. You can now ask:
- "List the most recent meetings in the archive"
- "Search for everything we discussed about the Hamburg rollout"
- "What did Sandra say about the Q3 budget?"
- "Pull the part of last Tuesday's all-hands where we talked about hiring"
The agent calls search_transcripts, gets back matching snippets with their transcript ids, pulls the full text through get_transcript where it needs context, and synthesizes an answer. If you ask for citations, it surfaces them.
4. Automate the upload
The most common gap is "I have audio but it never lands in DeepScript." The simplest fix is a folder-watcher script:
import os, time, requests
from pathlib import Path
WATCH = Path("~/Recordings").expanduser()
API_KEY = os.environ["DS_API_KEY"]
uploaded = set()
while True:
for f in WATCH.glob("*.{mp3,wav,m4a,mp4}"):
if f.name in uploaded:
continue
with open(f, "rb") as fh:
r = requests.post(
"https://api.deepscript.com/v1/transcriptions",
headers={"Authorization": f"Bearer {API_KEY}"},
files={"file": fh},
data={"model": "premium"},
)
if r.ok:
uploaded.add(f.name)
time.sleep(60)The upload carries no directory: an API key belongs to exactly one directory, so the key you use decides where the transcript lands. That is also the mechanism for scoping agent access – one key per directory, not one key for everything.
For Zoom-style recordings, the cloud-recording webhooks let you skip the local file: subscribe to recording.completed, fetch the file with the recording token, POST to DeepScript. About 50 lines of Python or Node.
What this enables
Practical use cases we see teams build:
Sales-call retrieval. "Find the call where we promised the customer X by Y" – instead of listening to 40 calls. Citations land you on the exact minute.
Research synthesis. A qualitative researcher with 30 anonymized interview transcripts can ask "what themes emerged around topic X" and get summaries grounded in actual quotes.
Compliance review. Legal asks "did anyone discuss [sensitive topic] in customer-facing meetings last quarter?" The agent runs a structured search and produces a report with timestamps.
Onboarding. "What did we decide about [project] in the last six months?" – new hires get a chronologically ordered summary instead of asking five colleagues.
Personal memory. Founders who record every external meeting get a queryable interface to everything they have said and heard.
The pattern is the same in each case: questions that previously required either listening to recordings or interrogating colleagues are now answerable from a chat interface.
What you should not do
A few things this architecture is not good at, and where teams get burned:
Real-time decision support. MCP-mediated retrieval has latency (a few seconds per query). It is not the right primitive for in-meeting assistants – for that, you want streaming transcription with on-the-fly summarization.
Highly sensitive content with broad agent access. If your transcripts contain attorney-client privileged content, medical records, or HR confidential material, scope tokens narrowly. Do not give a general-purpose agent access to a directory containing material it should not see – agents follow instructions but they also follow accidental ones.
Replacing memory. Agents querying a transcript archive are good at retrieval and summarization. They are not good at deciding what is important. The transcript is the source of truth; the agent's summary is a useful but lossy view.
Skipping the privacy review. Permanent retention of audio means permanent custody. Decide what the deletion path looks like *before* you start hoarding. DeepScript's DELETE /v1/transcriptions/{id} works on Pro-archived material the same way as on default-retention material, but you should have a documented retention/deletion policy before you accumulate a year of recordings.
Privacy implications you actually need to think about
Putting an agent in front of an audio archive concentrates a lot of organizational knowledge in one place. That is the point – but it raises the stakes for access control:
Who holds the API key, and which directory does it belong to? A key on "all sales calls" is far more powerful than one on "calls I was personally on". Since a key belongs to exactly one directory, the scoping tool is the directory layout: create one key per use case rather than one key for the whole account.
Where does the agent itself run? A self-hosted agent running on your infrastructure handles the transcripts on your hardware. A cloud-hosted agent (Claude Desktop talking to Anthropic's API) sends queries and retrieved content to a third party. That may or may not be acceptable depending on the content. For European customers with GDPR-bound data: read the agent vendor's data processing terms carefully, sign their DPA, and document the data flow in your record of processing activities.
Audit trail. Decide up front how you will notice misuse. Every key carries a lastUsedAt stamp, and access events land in the account audit log; review it periodically rather than after an incident.
Data subject rights. If transcripts contain personal data of identifiable individuals (interview subjects, customers, employees), the GDPR right to erasure applies to the transcripts as well as the audio. DeepScript supports per-transcript deletion that propagates to all replicas.
Closing thought
The combination of cheap transcription, structured storage, and standardized agent protocols is genuinely new. Five years ago, "make our archive AI-queryable" was a six-figure consulting engagement. Today it is a weekend project – three components, each commodity, glued together with about 100 lines of code.
The bottleneck is not technology anymore. It is deciding what to archive, who gets access, and how to retire material when it becomes a liability. Those are organizational questions, not engineering ones.
If you want to try this with DeepScript, the API documentation is at api.deepscript.com/docs. Three free transcriptions on signup, no credit card required to evaluate.