GPT-4 Reading Local Files via MCP Server

Contenido del curso

Introducción a MCP

Conceptos basicos de MCP

MCP avanzado

Integrando tu MCP con un agente

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0014:09

GPT-4 Reading Local Files via MCP Server

Curso de MCP con Microsoft Azure

Clase 15 de 22

Clase 15 / 22

Recursos

Connecting an MCP server to a large language model on Azure unlocks the real power of the Model Context Protocol: letting an AI read your files and answer in natural language. Here you'll learn how to deploy GPT-4 in Azure AI Foundry, wire it into a Python MCP server, and run prompts that query local files through the file system server.

This walkthrough is for developers who already have an Azure subscription and want to combine an MCP server with an LLM in a single script, using the agents.MCP library instead of the more common FastMCP.

How do I deploy a GPT-4 model in Azure AI Foundry?

The deployment lives inside a resource group and takes only a few clicks once your subscription is active. The free tier is enough for this exercise, so you won't burn the credit Azure gives you.

Inside the Azure portal, create a resource of type Azure AI Foundry under your resource group (in the demo, Platzi RG). Once created, open the Azure AI Foundry portal and go to Models and endpoints, then choose Deploy base model and pick GPT-4. After confirming, the model appears in the resources panel ready to use.

Click the deployment name and copy three values you'll need later:

API version.
Endpoint URL.
Access key.

What is Azure AI Foundry used for in an MCP setup? It hosts the LLM (like GPT-4) that your MCP server will call to interpret prompts and format responses. Foundry provides the endpoint, key, and API version your client needs to authenticate.

How do I configure the .env file and Python imports?

The credentials never go in the code directly. They live in an environment file that the Python client reads at runtime.

In the class 14 folder of the course repository you'll find an env-sample file. Rename it to .env and paste the three values from Foundry plus the deployment model name. That's the only configuration step before touching code.

In main_azure_ai_foundry.py, the imports cover async execution, OS access, and the MCP layer. The key shift here: instead of FastMCP, this example uses agents.MCP, a different library for building servers and agents. Keep this in mind because the ecosystem offers several valid options.

How does the MCP server talk to the LLM and read local files?

The script defines a function called get_azure_openai_client that loads the .env credentials into an AsyncAzureOpenAI client. That client becomes the bridge between your prompts and GPT-4.

Then comes the ejecutar function, which mixes both roles, server and client, in the same file. This is perfectly valid and convenient when you want results printed straight to the console. The agent is named file assistant and receives a system prompt instructing it to read files and answer questions based on them. The chat completion model points to the deployment name stored in .env.

What prompts does the agent run?

The demo uses three static prompts against a sample_files folder containing favorite_books.txt, favorite_cities.txt, and favorite_songs.txt:

Read the files in the sample files folder and list the file names.
What is my favorite book? Look at favorite_books.txt.
Look at my favorite songs.

The same code block runs each prompt, so a for loop over a list of prompts is the natural next step to scale this pattern.

What does the file_system server do inside MCP? It's an official MCP server (@modelcontextprotocol/server-filesystem) that exposes a restricted set of folders to the agent. Only the directories you whitelist can be read, which protects user privacy.

How do I run the project locally with a virtual environment?

A clean virtual environment avoids version clashes and makes the install reproducible.

From the class 14 directory, create and activate the environment:

python -m venv venv to create it.
source venv/bin/activate to activate it.
pip install -r requirements.txt to install dependencies.

A common trap: outside the venv you'd call python3, but inside the activated environment you use python. Mixing them up is a frequent source of confusion.

Once dependencies finish installing, run the script and watch the three prompts execute in sequence.

What output should I expect?

The terminal first confirms the MCP file system server is running and shows the whitelisted directories. Then each prompt prints its answer:

The first lists the three files in sample_files.
The second returns the contents of favorite_books.txt but notes that no specific favorite is marked, a reminder that prompt phrasing matters (asking for favorite book number one would have worked better).
The third reads the songs file and even suggests Living on a Prayer by Bon Jovi as a recommendation.

This flow shows the full loop: you write a natural-language question, the LLM interprets it, the MCP server fetches the file data, and the LLM formats the answer back into human-readable text inside your host application, the terminal.

Replace the sample files with your own books, cities, and songs, refine the prompts that didn't return what you expected, and add new questions to see how tightly the LLM and the MCP server can work together. What prompt would you try first?

Juan Sebastián Martinez Caldas

Hace un año

Casi no puedo lograr esta clase, así que comparto el codigo que me funcionó en Windows por si a alguien le sirve:

import asyncio

import os

from agents import Agent, OpenAIResponsesModel, Runner

from agents.mcp import MCPServerStdio

from dotenv import load_dotenv

from openai import AsyncAzureOpenAI

import os, shutil

import shutil

def resolve_fs_server_command(data_dir: str):

# A) Usar npx por ruta absoluta

npx = shutil.which("npx") or r"C:\Program Files\nodejs\npx.cmd"

if npx and os.path.isfile(npx):

return npx, ["-y", "@modelcontextprotocol/server-filesystem", data_dir]

# B) Fallback: node + dist/index.js (usando npm root -g)

node = shutil.which("node") or r"C:\Program Files\nodejs\node.exe"

js = os.path.join(r"C:\Program Files\nodejs\node_modules",

"@modelcontextprotocol", "server-filesystem", "dist", "index.js")

if node and os.path.isfile(node) and os.path.isfile(js):

return node, [js, data_dir]

raise FileNotFoundError(

"No encontré npx ni node+dist/index.js. Verifica tu instalación de Node.js."

)

def resolve_mcp_command():

# 1) Intenta server-filesystem global (rápido y sin npx)

appdata = os.environ.get("APPDATA", "")

candidate = os.path.join(appdata, "npm", "server-filesystem.cmd")

if os.path.isfile(candidate):

return candidate, "server-filesystem"

# 2) Si no existe, intenta encontrar npx absoluto

npx = shutil.which("npx") or r"C:\Program Files\nodejs\npx.cmd"

if npx and os.path.isfile(npx):

return npx, "npx"

# 3) Último recurso: falla explícito con mensaje claro

raise FileNotFoundError(

"No pude encontrar 'server-filesystem.cmd' ni 'npx'. "

"Instala Node.js y/o ejecuta: npm i -g @modelcontextprotocol/server-filesystem"

)

def get_azure_openai_client():

load_dotenv()

return AsyncAzureOpenAI(

api_key=os.getenv("AZURE_OPENAI_API_KEY"),

azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),

api_version=os.getenv("AZURE_OPENAI_API_VERSION"),

)

async def run_with_tools(mcp_server):

azure_openai_client = get_azure_openai_client()

model = OpenAIResponsesModel(

model=os.getenv("AZURE_OPENAI_CHAT_DEPLOYMENT_NAME"), # deployment name en Azure

openai_client=azure_openai_client,

)

agent = Agent(

name="Azure AI Foundry Agent",

instructions="Usa las herramientas para leer los archivos del sistema y responder preguntas basadas en esos archivos.",

model=model,

mcp_servers=[mcp_server],

)

msg = "Lee los archivos en la carpeta 'data' y enlista los nombres de los archivos."

print(f"[Agent] Ejecutando: {msg}")

result = await Runner.run(starting_agent=agent, input=msg)

print(result.final_output)

msg = "¿Cuál es mi libro favorito? Mira el archivo 'libros_favoritos.txt'."

print(f"[Agent] Ejecutando: {msg}")

result = await Runner.run(starting_agent=agent, input=msg)

print(result.final_output)

async def main():

current_dir = os.path.dirname(os.path.abspath(__file__))

data_dir = os.path.abspath(os.path.join(current_dir, "data"))

cmd, args = resolve_fs_server_command(data_dir)

print("[MCP] Lanzando filesystem server:", cmd, args)

async with MCPServerStdio(

name="File system server",

params={"command": cmd, "args": args, "cwd": current_dir},

) as mcp_server:

print("[MCP] Servidor inicializado; preparando tools MCP…")

# Debug: ver qué herramientas están disponibles

print(f"[MCP] Tipo de servidor: {type(mcp_server).__name__}")

print(f"[MCP] Tiene 'initialize': {hasattr(mcp_server, 'initialize')}")

print(f"[MCP] Tiene 'describe': {hasattr(mcp_server, 'describe')}")

print(f"[MCP] Tiene 'list_tools': {hasattr(mcp_server, 'list_tools')}")

# Usar list_tools() que SI existe en MCPServerStdio

if hasattr(mcp_server, "list_tools") and callable(getattr(mcp_server, "list_tools")):

try:

tools = await mcp_server.list_tools()

print(f"[MCP] Herramientas disponibles: {len(tools)} encontradas")

for tool in tools:

tool_name = getattr(tool, 'name', str(tool))

print(f" - {tool_name}")

except Exception as e:

print(f"[MCP] Error listando herramientas: {e}")

else:

print("[MCP] El servidor NO tiene metodo 'list_tools()' disponible")

# Pasar el servidor MCP directamente al agente

await run_with_tools(mcp_server)

if __name__ == "__main__":

asyncio.run(main())

mi pyproject es: [project]

name = "mcp-class"

version = "0.1.0"

description = "Add your description here"

readme = "README.md"

requires-python = ">=3.10"

dependencies = [

"azure-ai-inference>=1.0.0b9",

"azure-core>=1.36.0",

"mcp[cli]>=1.17.0",

"openai>=2.6.1",

"openai-agents>=0.4.2",

"python-dotenv>=1.1.1",

"uvicorn>=0.37.0",

]

Comentarios (14)14 comentarios

Miguel Gutierrez

Andrea Alexandra Mora Vega

Hace 8 meses•editado

Juan Pablo Serrano Echeverría

Hace 8 meses

Javier Medel

Daniel Alejandro Ramirez Gomez

David Herrera

Jose Ever Muñoz Muñoz

HERNANDO RAMIREZ

Hace 6 meses

Juan Sebastian Ramirez Leyva

Nery Alberto Cano Ortigoza

andres reyes

Amin Espinoza

Profesor

Introducción a MCP

Introducción a MCP

MCP Core Architecture: Server, Client, and Host

MCP Dev Environment Setup for Python

MCP Server Setup With Python and Inspector

Conceptos basicos de MCP

Four Core Blocks of Every MCP Server

Building an MCP Client That Talks to Your Server

Adding an LLM to Your MCP Client

STDIO vs SSE in MCP Servers

LLM Connected to a Local MCP Server

Testing MCP Servers Without a Browser

Deploying an MCP Server to Azure Container Apps

Using MCP Servers in VS Code Agent Mode

MCP avanzado

Query Azure Resources Directly From VS Code

Herramientas avanzadas de MCP para optimizar servidores y seguridad

GPT-4 Reading Local Files via MCP Server

Image Brightness Analysis with MCP and NumPy

How MCP Agents Remember Conversations

Enrutamiento de herramientas con MCP Server

Integrando tu MCP con un agente

Building a Web Search MCP Server with SERP API

Adding News, Products and Q&A Tools to MCP

Why MCP Docs Already Feel Outdated

MCP as the New Standard for AI Systems

GPT-4 Reading Local Files via MCP Server

Progreso del curso

Introducción a MCP

Conceptos basicos de MCP

MCP avanzado

Integrando tu MCP con un agente

Recursos

Recursos