Cómo crear un generador de blogs de búsqueda en la web profunda basado en IA con mcp-use: una guía completa

Tabla de contenidos

Introducción

En el cambiante panorama de la IA y el desarrollo web, el Protocolo de Contexto de Modelo (MCP) se ha convertido en un potente marco para crear aplicaciones inteligentes que integran a la perfección múltiples servicios y herramientas de IA. Este artículo explora el desarrollo de un generador de blogs basado en IA que aprovecha MCP para realizar búsquedas web profundas, generar contenido y guardar archivos automáticamente.

Trabajar con varios servidores MCP 🪐🪐

Un servidor MCP es genial, pero los flujos de trabajo reales suelen requerir varios backends especializados: por ejemplo, extraer datos de la web, consultar una base de datos y editar archivos, todo en un solo agente. Buenas noticias: MCP-Use se creó precisamente para esto.

¿Qué es mcp_use?

Es una biblioteca cliente MCP de código abierto. Facilita la conexión de cualquier LLM a cualquier servidor MCP.

El proyecto demuestra cómo crear una aplicación web lista para producción que combina:

Capacidades de búsqueda web mediante el servidor Linkup MCP
Generación de contenido con IA mediante modelos DeepSeek a través de la API de Groq
Gestión de archivos mediante el servidor del sistema de archivos MCP
Interfaz web moderna con FastAPI y diseño responsivo
Se mostrará la imagen ampliada

Descripción general del proyecto

El generador de blogs MCP es una aplicación web que permite a los usuarios:

Introducir un tema de blog a través de una interfaz web intuitiva.
Buscar automáticamente información relevante en la web mediante el servidor MCP Linkup.
Generar entradas de blog atractivas mediante modelos de IA con emojis y contenido interesante.
Guardar automáticamente las entradas de blog en un almacén de archivos local mediante el servidor del sistema de archivos MCP.
Descargar y compartir el contenido generado.

Características principales

🔍 Búsqueda web inteligente: Búsqueda en tiempo real con el servidor Linkup MCP
🤖 Generación de contenido con IA: Publicaciones de blog de alta calidad con DeepSeek-r1-distill-llama-70b
💾 Gestión automática de archivos: Guardado fluido con el servidor del sistema de archivos MCP
📱 Interfaz web adaptable: Interfaz de usuario moderna con componentes DaisyUI
⚡ Rendimiento rápido: Creado con FastAPI para operaciones de alta velocidad
🔄 Automatización del flujo de trabajo: Proceso completo de generación de blogs de principio a fin

Pila de tecnología

Backend Framework

FastAPI: Marco web moderno y rápido para crear API con Python
Uvicorn: Servidor ASGI para ejecutar aplicaciones FastAPI
Jinja2: Motor de plantillas para la generación dinámica de HTML

Integración de IA y MCP

MCP (Protocolo de Contexto de Modelo): Marco para conectar modelos de IA con herramientas y fuentes de datos
mcp-use: Biblioteca de Python para la gestión de clientes y agentes de MCP
LangChain: Marco para crear aplicaciones con LLM
Groq API: Plataforma de inferencia de alto rendimiento para modelos de IA

Modelos de IA

DeepSeek-r1-distill-llama-70b: Modelo de lenguaje avanzado para la generación de contenido
OpenAI-4O-mini: Cerebro del agente

Servidor MCP de enlace: Capacidades de búsqueda web
Servidor MCP del sistema de archivos: Operaciones de gestión de archivos

Frontend y estilo

DaisyUI: Biblioteca de componentes para Tailwind CSS
Tailwind CSS: Framework CSS orientado a la utilidad
Font Awesome: Biblioteca de iconos
Diseño adaptable: Enfoque móvil

Herramientas de desarrollo

Python 3.12: Lenguaje de programación
pip/uv: Gestión de paquetes
Git: Control de versiones
Windows 10/11: Entorno de desarrollo

Arquitectura y flujo de trabajo

Arquitectura del sistema

Proceso de flujo de trabajo

Entrada del usuario: El usuario introduce un tema de blog a través de la interfaz web.
Búsqueda web: El agente de MCP utiliza el servidor Linkup para buscar información relevante.
Visualización de resultados de búsqueda: Los resultados se muestran al usuario para su revisión.
Generación de contenido: El modelo de IA genera una entrada de blog atractiva basada en los resultados de búsqueda.
Guardado de archivos: La entrada de blog se guarda automáticamente en el almacén de archivos mediante el servidor del sistema de archivos de MCP.
Visualización de resultados: El usuario puede ver, descargar y compartir la entrada de blog generada.

Instalación y configuración

Requisitos

Python 3.12 o superior
Node.js y npm (para servidores MCP)
Gestor de paquetes UV (para dependencias de Python)
Clave API de Groq
Clave API de Linkup

Paso 1: Clonar y configurar el proyecto

cd mcpuse_dir

# Create virtual environment
python -m venv my_env
my_env\Scripts\activate # Windows
# source my_env/bin/activate # Linux/Mac

Paso 2: Instalar las dependencias de Python

# Install required packages
 pip install fastapi uvicorn jinja2 python-dotenv
 pip install mcp-use langchain-groq langchain-openai
 pip install python-multipart
 
 # Or using uv
 uv pip install fastapi uvicorn jinja2 python-dotenv
 uv pip install mcp-use langchain-groq langchain-openai
 uv pip install python-multipart

Paso 3: Instalar servidores MCP

# Install Linkup search server
 uv pip install mcp-search-linkup
 
 # Install filesystem server
 npm install -g @modelcontextprotocol/server-filesystem

Paso 4: Configurar las variables de entorno
Crea un archivo .env en la raíz del proyecto:

GROQ_API_KEY=your_groq_api_key_here
LINKUP_API_KEY=your_linkup_api_key_here

Paso 5: Configurar servidores MCP
Crear multiserver_setup_config.json:

{
  "mcpServers": {
    "linkup": {
      "command": "uvx",
      "args": ["mcp-search-linkup"],
      "env": {
        "LINKUP_API_KEY": "Your Linkup API Key"
      }
    },
    "filesystem": {
      "command": "C:\\Program Files\\nodejs\\npx.cmd",
      "args": [
        "@modelcontextprotocol/server-filesystem",
        "./filestore"
      ]
    }
  }
}

Paso 6: Crear la estructura del directorio

mkdir filestore
 mkdir static
 mkdir templates

Paso 7: Ejecutar la aplicación

python app.py

La aplicación estará disponible en http://127.0.0.1:8000

Registros de respuesta

(my_env) C:\Users\nayak\Documents\mcpuse_dir>python app.py
INFO:     Started server process [37032]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     127.0.0.1:60206 - "GET / HTTP/1.1" 200 OK
2025-07-13 22:20:01,111 - mcp_use.telemetry.telemetry - INFO - Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable.
🔍 Performing web search for: TOP AI News in 2025
2025-07-13 22:20:01,115 - mcp_use - INFO - 🚀 Initializing MCP agent and connecting to services...
2025-07-13 22:20:01,116 - mcp_use - INFO - 🔌 Found 0 existing sessions
2025-07-13 22:20:01,117 - mcp_use - INFO - 🔄 No active sessions found, creating new ones...
2025-07-13 22:20:15,464 - mcp_use - INFO - ✅ Created 2 new sessions
2025-07-13 22:20:15,743 - mcp_use - INFO - 🛠️ Created 13 LangChain tools from client
2025-07-13 22:20:15,744 - mcp_use - INFO - 🧰 Found 13 tools across all connectors
2025-07-13 22:20:15,746 - mcp_use - INFO - 🧠 Agent ready with tools: search-web, read_file, read_multiple_files, write_file, edit_file, create_directory, list_directory, list_directory_with_sizes, directory_tree, move_file, search_files, get_file_info, list_allowed_directories
2025-07-13 22:20:15,970 - mcp_use - INFO - ✨ Agent initialization complete
2025-07-13 22:20:15,971 - mcp_use - INFO - 💬 Received query: 'Use the 'linkup' server to search for: TOP AI News...'
2025-07-13 22:20:15,972 - mcp_use - INFO - 🏁 Starting agent execution with max_steps=30
2025-07-13 22:20:15,972 - mcp_use - INFO - 👣 Step 1/30
2025-07-13 22:20:24,500 - mcp_use - INFO - 🔧 Tool call: search-web with input: {'query': 'TOP AI News in 2025', 'depth': 'standard'}
2025-07-13 22:20:24,502 - mcp_use - INFO - 📄 Tool result: results=[LinkupSearchTextResult(type='text', name='Latest AI Breakthroughs and News: May, June, J...
2025-07-13 22:20:24,502 - mcp_use - INFO - 👣 Step 2/30
2025-07-13 22:20:31,758 - mcp_use - INFO - ✅ Agent finished at step 2
2025-07-13 22:20:31,759 - mcp_use - INFO - 🎉 Agent execution complete in 30.64415144920349 seconds
INFO:     127.0.0.1:60207 - "POST /search HTTP/1.1" 200 OK
📝 Generating blog post for: TOP AI News in 2025
💾 Saving blog post to filestore...
2025-07-13 22:20:49,700 - mcp_use - INFO - 🚀 Initializing MCP agent and connecting to services...
2025-07-13 22:20:49,700 - mcp_use - INFO - 🔌 Found 0 existing sessions
2025-07-13 22:20:49,700 - mcp_use - INFO - 🔄 No active sessions found, creating new ones...
2025-07-13 22:21:04,056 - mcp_use - INFO - ✅ Created 2 new sessions
2025-07-13 22:21:04,107 - mcp_use - INFO - 🛠️ Created 13 LangChain tools from client
2025-07-13 22:21:04,107 - mcp_use - INFO - 🧰 Found 13 tools across all connectors
2025-07-13 22:21:04,107 - mcp_use - INFO - 🧠 Agent ready with tools: search-web, read_file, read_multiple_files, write_file, edit_file, create_directory, list_directory, list_directory_with_sizes, directory_tree, move_file, search_files, get_file_info, list_allowed_directories
2025-07-13 22:21:04,233 - mcp_use - INFO - ✨ Agent initialization complete
2025-07-13 22:21:04,233 - mcp_use - INFO - 💬 Received query: 'Use the tool `write_file` from the `filesystem` se...'
2025-07-13 22:21:04,235 - mcp_use - INFO - 🏁 Starting agent execution with max_steps=30
2025-07-13 22:21:04,235 - mcp_use - INFO - 👣 Step 1/30
2025-07-13 22:21:16,897 - mcp_use - INFO - 🔧 Tool call: write_file with input: {'path': 'filestore/blog_top_ai_news_in_2025_20250713_222049.md', 'content': "# Top AI News in 20...
2025-07-13 22:21:16,897 - mcp_use - INFO - 📄 Tool result: Successfully wrote to filestore/blog_top_ai_news_in_2025_20250713_222049.md
2025-07-13 22:21:16,897 - mcp_use - INFO - 👣 Step 2/30
2025-07-13 22:21:18,303 - mcp_use - INFO - ✅ Agent finished at step 2
2025-07-13 22:21:18,303 - mcp_use - INFO - 🎉 Agent execution complete in 28.603514909744263 seconds
INFO:     127.0.0.1:60217 - "POST /generate_blog HTTP/1.1" 200 OK

Archivo escrito en el directorio del almacén de archivos

Blog generado

# Top AI News in 2025: The Future Is Here! 🚀🤖

Welcome to the world of Artificial Intelligence in 2025, where innovation is moving at lightning speed, and the implications for society are profound. Buckle up as we explore the most exciting AI news stories that are shaping our future!

## 1. OpenAI Unveils GPT-4.5: The Emotional AI Revolution 💬❤️

On February 28, 2025, OpenAI took a giant leap forward with the launch of GPT-4.5! This cutting-edge model focuses on enhanced emotional intelligence, enabling more human-like conversations. Imagine chatting with an AI that truly understands your feelings and responds with empathy. This breakthrough could revolutionize customer service, therapy, and personal assistants, making our interactions with technology more meaningful than ever. [Read more](https://www.crescendo.ai/news/latest-ai-news-and-updates).

## 2. Mira Murati’s Thinking Machines Lab: A $2 Billion Vision 💡💰

Mira Murati, a visionary in AI, raised an astonishing $2 billion at a $10 billion valuation for her new venture, Thinking Machines Lab. The aim? To develop advanced agentic AI systems that can think and learn autonomously. This ambitious project could redefine the role of AI in decision-making across industries, from finance to healthcare. Get ready for machines that not only assist but also collaborate! [Read more](https://www.crescendo.ai/news/latest-ai-news-and-updates).

## 3. China’s AI Response: A New Era of Independence 🇨🇳⚙️

In a bold move following U.S. trade restrictions, China is accelerating its AI development. With a focus on national independence in technology, new models and collaborations are emerging at a rapid pace. This shift is reshaping the global AI landscape, highlighting the need for nations to bolster their tech ecosystems to remain competitive. [Read more](https://www.crescendo.ai/news/latest-ai-news-and-updates).

## 4. U.S. AI Leadership Concerns: A Call to Action 📈🇺🇸

Blake Moore, a prominent tech advisor, issued a wake-up call regarding potential complacency in U.S. AI leadership. His message is clear: immediate action is needed to maintain a competitive edge against rising powers like China. This call for vigilance emphasizes the importance of innovation and investment to secure the future of AI in America. [Read more](https://www.crescendo.ai/news/latest-ai-news-and-updates).

## 5. Google’s AI Integration: Enhancing Everyday Life 🛍️🔍

Google has been busy integrating AI into various products, from enhanced search features to new shopping experiences. But that's not all! The tech giant is also leveraging AI to improve healthcare and education, aiming to make life easier and more efficient for everyone. With AI as a core component of their strategy, Google is setting the stage for a smarter future! [Read more](https://blog.google/technology/ai/google-ai-updates-june-2025/).

## 6. Stanford’s AI Index Report: Responsible AI Growth 📊🌍

The 2025 AI Index from Stanford highlights the rapid growth of AI models, with increasing emphasis on responsible AI practices. This report sheds light on the economic impacts of AI and the importance of ethical considerations as we advance. As AI continues to permeate our lives, ensuring that it benefits all of humanity is more critical than ever. [Read more](https://hai.stanford.edu/ai-index/2025-ai-index-report).

## 7. AI Startup Boom: The Future is Now! 🌟🚀

The AI startup ecosystem is thriving, with significant investments flowing into generative AI and automation technologies. These innovative companies are pushing the boundaries of what's possible, creating solutions that could transform industries overnight. Keep an eye on this space—it's where tomorrow's breakthroughs are happening today! [Read more](https://www.crn.com/news/ai/2025/the-10-hottest-ai-startup-companies-of-2025-so-far).

## 8. The Global AI Divide: Bridging the Gap 🌐⚖️

A recent report underscores a growing disparity in AI computing power between nations, leading to unequal access to technology and capabilities. As some countries race ahead, others risk being left behind. Addressing this global AI divide is crucial for ensuring equitable access and fostering a balanced technological future. [Read more](https://www.nytimes.com/interactive/2025/06/23/technology/ai-computing-global-divide.html).

---

As we delve deeper into 2025, it's clear that AI is no longer just a futuristic concept—it's an integral part of our daily lives. From emotional conversations with AI companions to the rise of innovative startups, the advancements in this field promise a transformative impact on society. Stay tuned, because the AI revolution is just getting started! 🌟✨

✅ Resumen de éxito:

Ambos servidores se conectaron correctamente:
- ✅ Servidor de enlace (usando uvx mcp-search-linkup)
- ✅ Servidor de sistema de archivos (usando C:\Archivos de programa\nodejs\npx.cmd)
Inicialización del agente completada:
- ✅ Se crearon 2 nuevas sesiones
- ✅ Se encontraron 13 herramientas en todos los conectores
- ✅ Agente listo con herramientas: búsqueda web, lectura de archivo, escritura de archivo, etc.
Flujo de trabajo completo ejecutado correctamente:
- ✅ Paso 1: Búsqueda web de los «5 mejores frameworks de Agentic» completada
- ✅ Paso 2: Generación de la entrada del blog completada
- ✅ Paso 3: Archivo guardado correctamente en filestore/Top_5_Agentic_AI_Frameworks.md

Detalles y uso de la biblioteca

Bibliotecas principales

MCP (Protocolo de Contexto de Modelo)

Propósito: Marco para conectar modelos de IA con herramientas y fuentes de datos
Características principales:
– Comunicación estandarizada entre modelos de IA y herramientas
– Compatibilidad con múltiples tipos de servidores (búsqueda, sistema de archivos, etc.)
– Arquitectura extensible para servidores personalizados
Uso: Permite la integración fluida de la búsqueda web y las operaciones con archivos

mcp-use

Propósito: Biblioteca de Python para la gestión de clientes y agentes MCP
Características principales:
– Creación y gestión simplificada de clientes MCP
– Capacidades de agente integradas para la orquestación de herramientas
– Gestión de sesiones y conexiones
Uso: Crea agentes MCP que pueden usar varios servidores simultáneamente

FastAPI

Propósito: Framework web moderno para crear API
Características principales:
– Alto rendimiento con compatibilidad asíncrona
– Documentación automática de la API
– Sugerencias de tipo y validación
– Fácil integración con frameworks frontend
Uso: Proporciona el servidor web y los puntos finales de la API para el generador de blogs

LangChain

Propósito: Marco para la creación de aplicaciones con LLM
Características principales:
– Abstracciones de cadena y agente
– Capacidad de integración de herramientas
– Gestión de memoria y estado
– Compatibilidad con múltiples proveedores de LLM
Uso: Orquesta las interacciones de los modelos de IA y el uso de las herramientas

API de Groq

Propósito: Plataforma de inferencia de alto rendimiento
Características clave:
– Inferencia de modelos ultrarrápida
– Compatibilidad con múltiples tipos de modelos
– Precios competitivos
– Puntos finales de API fiables
Uso: Impulsa el modelo DeepSeek para la generación de contenido

Bibliotecas de integración

DaisyUI

Propósito: Biblioteca de componentes para Tailwind CSS
Características principales:
– Componentes prediseñados y accesibles
– Sistema de diseño consistente
– Fácil personalización
– Compatibilidad con diseño responsivo
Uso: Proporciona los componentes de interfaz de usuario para la interfaz web

Jinja2

Propósito: Motor de plantillas para Python
Características principales:
– Generación dinámica de HTML
– Herencia de plantillas
– Sustitución de variables
– Funciones de seguridad
Uso: Genera páginas HTML dinámicas con resultados de búsqueda y contenido de blogs

Detalles clave de la implementación

Configuración del agente MCP

def get_mcp_agent():
"""Initialize MCP agent with OpenAI model"""
    llm = ChatOpenAI(
        model="gpt-4o-mini",
        temperature=0.7,
        api_key=os.getenv("OPAPIKEY")
    )
 
 client = MCPClient.from_config_file("multiserver_setup_config.json")
 agent = MCPAgent(
 llm=llm,
 client=client,
 use_server_manager=False,
 max_steps=30
 )
 return agent

Implementación de búsqueda web

@app.post("/search")
 async def perform_web_search(request: Request, topic: str = Form(…)):
 agent = get_mcp_agent()
 search_result = await agent.run(
 f"Use the 'linkup' server to search for: {topic}"
 )
 # Return search results to template

Proceso de generación de blogs

@app.post("/generate_blog")
 async def generate_blog_post(request: Request, topic: str = Form(…), search_results: str = Form(…)):
 llm = ChatGroq(
 model="deepseek-r1-distill-llama-70b",
 temperature=0.7,
 api_key=os.getenv("GROQ_API_KEY")
 )
 
 blog_post = await llm.ainvoke(
 f"Write an engaging blog post about the topic: {topic} based on the search results: {search_results} Use emojis and make it interesting."
 )
 
 # Save to filestore using MCP filesystem server
 save_result = await agent.run(
 f"Use the tool `write_file` from the `filesystem` server and write filename: '{filename}' at filestore directory and save content: {blog}"
 )

Gestión de archivos

La aplicación utiliza el servidor del sistema de archivos MCP para guardar automáticamente las entradas de blog generadas con marcas de tiempo y nombres de archivo descriptivos:

timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
 filename = f"blog_{topic.replace(' ', '_').lower()}_{timestamp}.md"

Implementación de código

Archivos de configuración del servidor

{
  "mcpServers": {
    "linkup": {
      "command": "uvx",
      "args": ["mcp-search-linkup"],
      "env": {
        "LINKUP_API_KEY": "YOUR API KEY"
      }
    },
    "filesystem": {
      "command": "C:\\Program Files\\nodejs\\npx.cmd",
      "args": [
        "@modelcontextprotocol/server-filesystem",
        "./filestore"
      ]
    }
  }
}

FastAPI aplicación

from fastapi import FastAPI, Request, Form, HTTPException
from fastapi.responses import HTMLResponse, RedirectResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
import asyncio
import os
from datetime import datetime
import json
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_groq import ChatGroq
from mcp_use import MCPAgent, MCPClient

load_dotenv()

app = FastAPI(title="MCP Blog Generator", version="1.0.0")

# Mount static files
app.mount("/static", StaticFiles(directory="static"), name="static")

# Templates
templates = Jinja2Templates(directory="templates")

# Global variable to store current blog results
current_blog = None

# Initialize MCP components
def get_mcp_agent():
    """Initialize MCP agent with OpenAI model"""
    llm = ChatOpenAI(
        model="gpt-4o-mini",
        temperature=0.7,
        api_key=os.getenv("OPAPIKEY")
    )
    # llm = ChatGroq(
    #     model="llama-3.3-70b-versatile",
    #     api_key=os.getenv("GROQ_API_KEY")
    # )
    client = MCPClient.from_config_file("multiserver_setup_config.json")
    agent = MCPAgent(
        llm=llm,
        client=client,
        use_server_manager=False,
        max_steps=30
    )
    return agent

@app.get("/", response_class=HTMLResponse)
async def home(request: Request):
    """Home page with blog topic form"""
    return templates.TemplateResponse("index.html", {"request": request})

@app.post("/search")
async def perform_web_search(
    request: Request,
    topic: str = Form(...)
):
    """Perform web search using MCP linkup server"""
    try:
        agent = get_mcp_agent()
        
        # Step 1: Perform web search
        print(f"🔍 Performing web search for: {topic}")
        search_result = await agent.run(
            f"Use the 'linkup' server to search for: {topic}"
        )
        
        if search_result:
            return templates.TemplateResponse(
                "search_results.html",
                {
                    "request": request,
                    "topic": topic,
                    "search_results": search_result,
                    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                }
            )
        else:
            raise HTTPException(status_code=500, detail="Search failed")
    except Exception as e:
        return templates.TemplateResponse(
            "error.html",
            {
                "request": request,
                "error": str(e),
                "topic": topic
            }
        )

@app.post("/generate_blog")
async def generate_blog_post(
    request: Request,
    topic: str = Form(...),
    search_results: str = Form(...)
):
    """Generate blog post from search results and save to filestore"""
    global current_blog
    try:
        agent = get_mcp_agent()
        
        llm = ChatGroq(
            model="deepseek-r1-distill-llama-70b",
            temperature=0.7,
            api_key=os.getenv("GROQ_API_KEY")
        )
        # Step 2: Generate blog post
        print(f"📝 Generating blog post for: {topic}")
        blog_post = await llm.ainvoke(
            f"Write an engaging blog post about the topic: {topic} based on the search results: {search_results} Use emojis and make it interesting."
        )
        
        if blog_post:
            # Step 3: Save blog post to filestore
            print(f"💾 Saving blog post to filestore...")
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = f"blog_{topic.replace(' ', '_').lower()}_{timestamp}.md"
            
            save_result = await agent.run(
                f"Use the tool `write_file` from the `filesystem` server and write filename: '{filename}' at filestore directory and save  content: {blog_post.content}"
            )
            
            result = {
                "topic": topic,
                "search_results": search_results,
                "blog_post": blog_post.content,
                "filename": filename,
                "save_result": save_result
            }
            current_blog = result
            
            return templates.TemplateResponse(
                "results.html",
                {
                    "request": request,
                    "blog": result,
                    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                }
            )
        else:
            raise HTTPException(status_code=500, detail="Blog generation failed")
    except Exception as e:
        return templates.TemplateResponse(
            "error.html",
            {
                "request": request,
                "error": str(e),
                "topic": topic
            }
        )

@app.get("/results")
async def view_results(request: Request):
    global current_blog
    if not current_blog:
        return RedirectResponse(url="/", status_code=303)
    return templates.TemplateResponse(
        "results.html",
        {
            "request": request,
            "blog": current_blog,
            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }
    )

@app.get("/download/{filename}")
async def download_file(filename: str):
    file_path = f"filestore/{filename}"
    if not os.path.exists(file_path):
        raise HTTPException(status_code=404, detail="File not found")
    from fastapi.responses import FileResponse
    return FileResponse(file_path, filename=filename)

@app.get("/api/status")
async def api_status():
    return {
        "status": "running",
        "timestamp": datetime.now().isoformat(),
        "has_blog": current_blog is not None
    }

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="127.0.0.1", port=8000)

🔬📚
Solución de problemas comunes

Problemas de compatibilidad con Windows
Problema: [WinError 193] %1 no es una aplicación Win32 válida
Solución: Use las rutas completas de los ejecutables en la configuración de MCP:
“comando”: “C:\Archivos de programa\nodejs\npx.cmd”

Problemas de conexión con el servidor MCP
Problema: Los servidores MCP no se conectan
Solución:

Asegúrese de que los servidores estén instalados globalmente
Compruebe las claves API en las variables de entorno
Verifique los comandos del servidor en el archivo de configuración

Problemas de renderizado de plantillas
Problema: Errores de plantilla de Jinja2
Solución: Instalar Jinja2 explícitamente:
pip install jinja2

Rendimiento y optimización
Métricas de rendimiento actuales

Tiempo de respuesta de búsqueda: 3-5 segundos
Tiempo de generación del blog: 10-15 segundos
Tiempo de guardado del archivo: 1-2 segundos
Tiempo total del flujo de trabajo: 15-25 segundos

Estrategias de optimización

Almacenamiento en caché: Implementar el almacenamiento en caché de los resultados de búsqueda
Procesamiento asíncrono: Utilizar tareas en segundo plano para operaciones de larga duración
Agrupación de conexiones: Optimizar las conexiones del servidor MCP
Integración con CDN: Servir recursos estáticos a través de CDN

Consideraciones de seguridad
Gestión de claves API
• Almacenar las claves API en variables de entorno
• Nunca enviar claves API al control de versiones
• Utilizar servicios seguros de gestión de claves en producción

Validación de entrada

Validar las entradas del usuario para prevenir ataques de inyección
Limpiar las consultas de búsqueda y los temas del blog
Implementar la limitación de velocidad para los endpoints de la API

Seguridad del sistema de archivos

Restringir el acceso al sistema de archivos a directorios específicos
Validar las rutas de los archivos para evitar ataques transversales de directorio
Implementar límites de tamaño y tipo de archivo

Conclusión

El Generador de Blogs MCP demuestra la potencia y la flexibilidad del Protocolo de Contexto de Modelo para la creación de aplicaciones web inteligentes. Al combinar múltiples servidores MCP con modelos avanzados de IA, hemos creado un sistema que puede:

Automatizar la búsqueda de contenido mediante la búsqueda web inteligente
Generar contenido de alta calidad utilizando modelos de IA de vanguardia
Gestionar archivos sin problemas mediante la integración del sistema de archivos MCP
Ofrecer una experiencia de usuario intuitiva con tecnologías web modernas

Logros clave

Integración perfecta: Se integraron con éxito varios servidores MCP con modelos de IA.
Listo para producción: Se creó una aplicación web completa con un manejo adecuado de errores.
Fácil de usar: Se creó una interfaz intuitiva para usuarios sin conocimientos técnicos.
Arquitectura extensible: Se diseñó para facilitar la incorporación de nuevas funciones y servidores.

Resultados del aprendizaje

Comprensión de la arquitectura MCP y la integración de servidores
Experiencia con API de modelos de IA modernos y generación de contenido
Conocimiento de desarrollo web FastAPI y programación asíncrona
El proyecto demuestra cómo las tecnologías emergentes como MCP pueden combinarse con prácticas de desarrollo web consolidadas para crear aplicaciones potentes e inteligentes que mejoran la productividad y la creatividad.