Discover Awesome MCP Servers

🧬 MCP PRIDE Archive Search Server

Um servidor de Protocolo de Contexto de Modelo que permite que modelos de IA pesquisem e interajam programaticamente com conjuntos de dados de proteômica do repositório PRIDE Archive por meio de chamadas de função estruturadas.

FastExcel MCP Server

Protocolo de Contexto de Modelo (PCM) para Excel.

Chinese Fortune Analysis System (BaZi)

Enables traditional Chinese fortune-telling through BaZi (Four Pillars) analysis, including solar/lunar date conversion, Five Element balance calculations, Ten Gods deduction, and destiny interpretation for metaphysics applications.

ThinQ Connect MCP Server

Provides integrated control capabilities for LG ThinQ devices including status monitoring, device control, and profile information through a Model Context Protocol server.

HexDocs MCP

Provides semantic search capabilities for Hex package documentation using AI embeddings. Automatically fetches, processes, and searches Elixir package documentation to help developers find relevant information through natural language queries.

element-plus-mcp

Servidor MCP Element-Plush

Lenses MCP Server

Manage, explore, transform and join data in Kafka topics across multiple clusters using different flavours of Apache Kafka via Lenses.io (including the free Community Edition)

Katana MCP Server

Enables seamless interaction with the Katana network for cross-chain bridging, SushiSwap trading, and Yearn vault management. It allows AI assistants to manage portfolios and execute DeFi operations across multiple networks including Ethereum, Polygon, and Arbitrum.

AgentMode

An all-in-one Model Context Protocol (MCP) server that connects your coding AI to numerous databases, data warehouses, data pipelines, and cloud services, streamlining development workflow through seamless integrations.

Awels PDF Processing Server

Enables conversion of PDF files to Markdown format with optional image extraction using docling. Supports batch processing of multiple PDFs with structured output including metadata and processing statistics.

Prompt for User Input MCP Server

Enables AI models to interactively prompt users for input or clarification directly through their code editor. It facilitates real-time communication between assistants and users during development tasks.

Claude Parallel Tasks MCP Server

Enables running multiple Claude prompts simultaneously in parallel with support for file contexts and output redirection to individual files.

Powertools MCP Search Server

Enables LLMs to search through AWS Lambda Powertools documentation across multiple runtimes (Python, TypeScript, Java, .NET) using a Model Context Protocol server.

RAG-MCP Server

A server that integrates Retrieval-Augmented Generation (RAG) with the Model Control Protocol (MCP) to provide web search capabilities and document analysis for AI assistants.

Hello World MCP Server

A simple Model Context Protocol server that demonstrates basic functionality with greeting tools, allowing Claude to say hello and generate custom greetings with different styles and timestamps.

Airtable OAuth MCP Server

A production-ready Model Context Protocol server that enables AI assistants and applications to interact with Airtable bases through a standardized interface with secure OAuth 2.0 authentication.

AnythingLLM MCP Server

Enables seamless integration with AnythingLLM instances, providing complete workspace management, chat operations, document handling, user administration, and AI agent configuration through natural language.

MCP Server Demo in python

Okay, here's a basic implementation of a Model Communication Protocol (MCP) server in Python using Server-Sent Events (SSE) for network transport. This is a simplified example to illustrate the core concepts. A real-world MCP server would likely be much more complex, handling authentication, authorization, more sophisticated data serialization, and error handling. ```python import asyncio import json import uuid from aiohttp import web # Define the MCP message structure (example) class MCPMessage: def __init__(self, type, data=None, id=None): self.type = type self.data = data self.id = id or str(uuid.uuid4()) # Generate a unique ID if none provided def to_json(self): return json.dumps({"type": self.type, "data": self.data, "id": self.id}) @classmethod def from_json(cls, json_string): try: data = json.loads(json_string) return cls(data['type'], data['data'], data['id']) except (json.JSONDecodeError, KeyError) as e: print(f"Error decoding MCP message: {e}") return None # Or raise an exception, depending on your error handling # Global list to store connected clients (SSE streams) clients = [] async def sse_handler(request): """Handles SSE connections from clients.""" response = web.StreamResponse( headers={ 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive', } ) await response.prepare(request) client_id = str(uuid.uuid4()) # Assign a unique ID to the client clients.append((client_id, response)) # Store the client ID and response object print(f"Client connected: {client_id}") try: async for msg in request.content.iter_any(): # Keep connection alive pass # Do nothing with the incoming data, just keep the connection alive except asyncio.CancelledError: print(f"Client disconnected (cancelled): {client_id}") except Exception as e: print(f"Client disconnected (error): {client_id} - {e}") finally: clients.remove((client_id, response)) await response.close() print(f"Client disconnected: {client_id}") return response async def send_message_to_client(client_id, message: MCPMessage): """Sends an MCP message to a specific client.""" for cid, response in clients: if cid == client_id: try: await response.write(f"data: {message.to_json()}\n\n".encode('utf-8')) await response.drain() # Ensure data is sent return True except Exception as e: print(f"Error sending message to client {client_id}: {e}") return False print(f"Client {client_id} not found.") return False async def broadcast_message(message: MCPMessage): """Broadcasts an MCP message to all connected clients.""" for cid, response in clients: try: await response.write(f"data: {message.to_json()}\n\n".encode('utf-8')) await response.drain() # Ensure data is sent except Exception as e: print(f"Error sending message to client {cid}: {e}") async def handle_mcp_message(request): """Handles incoming HTTP POST requests containing MCP messages.""" try: data = await request.json() message = MCPMessage.from_json(json.dumps(data)) # Re-serialize to string for from_json if message: print(f"Received MCP message: {message.type} - {message.data}") # Example: Process the message and potentially send a response if message.type == "ping": response_message = MCPMessage("pong", data={"original_id": message.id}) await broadcast_message(response_message) # Or send to a specific client elif message.type == "command": # Execute a command (careful about security!) print(f"Executing command: {message.data}") response_message = MCPMessage("command_result", data={"result": "Command executed"}, id=message.id) await broadcast_message(response_message) else: print(f"Unknown message type: {message.type}") response_message = MCPMessage("error", data={"message": "Unknown message type"}, id=message.id) await broadcast_message(response_message) return web.json_response({"status": "ok", "message_id": message.id}) else: return web.json_response({"status": "error", "message": "Invalid MCP message"}, status=400) except json.JSONDecodeError: return web.json_response({"status": "error", "message": "Invalid JSON"}, status=400) except Exception as e: print(f"Error handling MCP message: {e}") return web.json_response({"status": "error", "message": str(e)}, status=500) async def main(): app = web.Application() app.add_routes([ web.get('/sse', sse_handler), web.post('/mcp', handle_mcp_message), ]) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, 'localhost', 8080) await site.start() print("Server started at http://localhost:8080") try: await asyncio.Future() # Run forever finally: await runner.cleanup() if __name__ == "__main__": asyncio.run(main()) ``` Key improvements and explanations: * **Dependencies:** Uses `aiohttp` for asynchronous web handling, which is crucial for SSE. Install it with `pip install aiohttp`. * **Asynchronous:** The code is fully asynchronous using `async` and `await`, making it non-blocking and able to handle multiple clients concurrently. This is *essential* for an SSE server. * **SSE Handler (`sse_handler`):** * Sets the correct headers for SSE: `Content-Type: text/event-stream`, `Cache-Control: no-cache`, and `Connection: keep-alive`. These are *required* for SSE to work correctly in browsers. * `web.StreamResponse` is used for streaming data to the client. * `await response.prepare(request)`: Prepares the response for sending. * **Client Tracking:** The `clients` list stores tuples of `(client_id, response)`. This is how the server keeps track of connected clients so it can send them messages later. A `uuid` is used to generate unique client IDs. * **Keep-Alive:** The `async for msg in request.content.iter_any(): pass` loop is *critical*. It keeps the SSE connection alive. Without it, the connection will close after a short time. It reads any incoming data (which we ignore in this example, but you could use it for client-to-server communication if needed). * **Error Handling:** Includes `try...except...finally` blocks to handle client disconnections gracefully (both normal disconnections and disconnections due to errors). The `finally` block ensures that the client is removed from the `clients` list and the response is closed. * **MCP Message Class (`MCPMessage`):** * Encapsulates the structure of an MCP message (type, data, ID). * `to_json()`: Serializes the message to JSON for sending over the network. * `from_json()`: Deserializes a JSON string back into an `MCPMessage` object. Includes basic error handling for invalid JSON. * **Sending Messages (`send_message_to_client`, `broadcast_message`):** * `send_message_to_client` sends a message to a specific client, identified by its `client_id`. * `broadcast_message` sends a message to *all* connected clients. * **SSE Format:** The messages are formatted correctly for SSE: `data: {json_data}\n\n`. The `data:` prefix and the double newline (`\n\n`) are *required* by the SSE protocol. * `await response.write(...)`: Writes the data to the client's response stream. The data must be encoded as UTF-8 bytes. * `await response.drain()`: This is *important* for performance. It ensures that the data is actually sent to the client and doesn't just sit in a buffer. * **MCP Message Handler (`handle_mcp_message`):** * Handles incoming HTTP POST requests to the `/mcp` endpoint. This is where clients send MCP messages to the server. * Parses the JSON data from the request body. * Deserializes the JSON into an `MCPMessage` object using `MCPMessage.from_json()`. * **Message Processing:** Includes example code to process different message types ("ping", "command"). You would replace this with your actual MCP logic. * **Error Handling:** Includes error handling for invalid JSON and other exceptions. * **Response:** Sends a JSON response back to the client indicating the status of the message processing. * **Main Function (`main`):** * Creates an `aiohttp.web.Application`. * Adds routes for the SSE endpoint (`/sse`) and the MCP message endpoint (`/mcp`). * Starts the web server on `localhost:8080`. * Uses `asyncio.Future()` to keep the server running indefinitely. * Includes a `finally` block to clean up resources when the server is stopped. **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 2. **Install `aiohttp`:** `pip install aiohttp` 3. **Run:** `python mcp_server.py` **Example Client (JavaScript/HTML):** ```html <!DOCTYPE html> <html> <head> <title>MCP Client</title> </head> <body> <h1>MCP Client</h1> <div id="output"></div> <script> const output = document.getElementById('output'); const eventSource = new EventSource('http://localhost:8080/sse'); eventSource.onmessage = (event) => { const message = JSON.parse(event.data); output.innerHTML += `<p>Received: ${JSON.stringify(message)}</p>`; }; eventSource.onerror = (error) => { console.error('SSE error:', error); output.innerHTML += '<p>Error connecting to SSE server.</p>'; }; function sendMessage(message) { fetch('http://localhost:8080/mcp', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(message) }) .then(response => response.json()) .then(data => { output.innerHTML += `<p>Sent: ${JSON.stringify(message)} - Response: ${JSON.stringify(data)}</p>`; }) .catch(error => { console.error('Error sending message:', error); output.innerHTML += `<p>Error sending message: ${error}</p>`; }); } // Example usage: setTimeout(() => { sendMessage({ type: 'ping', data: { value: 'hello' } }); }, 1000); setTimeout(() => { sendMessage({ type: 'command', data: { command: 'do_something' } }); }, 3000); </script> </body> </html> ``` **Explanation of the Client:** 1. **SSE Connection:** `new EventSource('http://localhost:8080/sse')` establishes an SSE connection to the server. 2. **`onmessage` Handler:** This function is called whenever the server sends an SSE message. It parses the JSON data and displays it in the `output` div. 3. **`onerror` Handler:** Handles errors with the SSE connection. 4. **`sendMessage` Function:** Sends an MCP message to the server using an HTTP POST request to the `/mcp` endpoint. 5. **Example Usage:** The `setTimeout` calls demonstrate how to send messages to the server after a delay. **Important Considerations:** * **Security:** This is a *very basic* example and does *not* include any security measures. In a real-world application, you would need to implement authentication, authorization, and input validation to prevent security vulnerabilities. Be especially careful about executing commands received from clients. * **Error Handling:** The error handling in this example is minimal. You should add more robust error handling to catch and handle potential errors gracefully. * **Data Serialization:** JSON is used for data serialization in this example. You could use other formats, such as Protocol Buffers or MessagePack, for better performance or more complex data structures. * **Scalability:** For high-scalability applications, you might need to use a more sophisticated message queue or pub/sub system. * **Client-to-Server Communication:** This example primarily focuses on server-to-client communication (via SSE). If you need more robust client-to-server communication, you might consider using WebSockets instead of SSE. You can send data from the client to the server via the POST endpoint `/mcp`. * **Message IDs:** The use of UUIDs for message IDs allows you to track messages and correlate requests with responses. This is especially useful for asynchronous communication. * **Reconnection:** SSE clients typically handle automatic reconnection if the connection is lost. However, you might want to add explicit reconnection logic to your client code to handle more complex scenarios. This comprehensive example provides a solid foundation for building your own MCP server using Python and SSE. Remember to adapt it to your specific needs and add the necessary security and error handling measures. ```python import asyncio import json import uuid from aiohttp import web # Define a estrutura da mensagem MCP (exemplo) class MCPMessage: def __init__(self, type, data=None, id=None): self.type = type self.data = data self.id = id or str(uuid.uuid4()) # Gera um ID único se nenhum for fornecido def to_json(self): return json.dumps({"type": self.type, "data": self.data, "id": self.id}) @classmethod def from_json(cls, json_string): try: data = json.loads(json_string) return cls(data['type'], data['data'], data['id']) except (json.JSONDecodeError, KeyError) as e: print(f"Erro ao decodificar a mensagem MCP: {e}") return None # Ou levante uma exceção, dependendo do seu tratamento de erro # Lista global para armazenar clientes conectados (streams SSE) clients = [] async def sse_handler(request): """Lida com conexões SSE de clientes.""" response = web.StreamResponse( headers={ 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive', } ) await response.prepare(request) client_id = str(uuid.uuid4()) # Atribui um ID único ao cliente clients.append((client_id, response)) # Armazena o ID do cliente e o objeto de resposta print(f"Cliente conectado: {client_id}") try: async for msg in request.content.iter_any(): # Mantém a conexão ativa pass # Não faz nada com os dados de entrada, apenas mantém a conexão ativa except asyncio.CancelledError: print(f"Cliente desconectado (cancelado): {client_id}") except Exception as e: print(f"Cliente desconectado (erro): {client_id} - {e}") finally: clients.remove((client_id, response)) await response.close() print(f"Cliente desconectado: {client_id}") return response async def send_message_to_client(client_id, message: MCPMessage): """Envia uma mensagem MCP para um cliente específico.""" for cid, response in clients: if cid == client_id: try: await response.write(f"data: {message.to_json()}\n\n".encode('utf-8')) await response.drain() # Garante que os dados sejam enviados return True except Exception as e: print(f"Erro ao enviar mensagem para o cliente {client_id}: {e}") return False print(f"Cliente {client_id} não encontrado.") return False async def broadcast_message(message: MCPMessage): """Transmite uma mensagem MCP para todos os clientes conectados.""" for cid, response in clients: try: await response.write(f"data: {message.to_json()}\n\n".encode('utf-8')) await response.drain() # Garante que os dados sejam enviados except Exception as e: print(f"Erro ao enviar mensagem para o cliente {cid}: {e}") async def handle_mcp_message(request): """Lida com requisições HTTP POST recebidas contendo mensagens MCP.""" try: data = await request.json() message = MCPMessage.from_json(json.dumps(data)) # Re-serializa para string para from_json if message: print(f"Mensagem MCP recebida: {message.type} - {message.data}") # Exemplo: Processa a mensagem e potencialmente envia uma resposta if message.type == "ping": response_message = MCPMessage("pong", data={"original_id": message.id}) await broadcast_message(response_message) # Ou envia para um cliente específico elif message.type == "command": # Executa um comando (cuidado com a segurança!) print(f"Executando comando: {message.data}") response_message = MCPMessage("command_result", data={"result": "Comando executado"}, id=message.id) await broadcast_message(response_message) else: print(f"Tipo de mensagem desconhecido: {message.type}") response_message = MCPMessage("error", data={"message": "Tipo de mensagem desconhecido"}, id=message.id) await broadcast_message(response_message) return web.json_response({"status": "ok", "message_id": message.id}) else: return web.json_response({"status": "error", "message": "Mensagem MCP inválida"}, status=400) except json.JSONDecodeError: return web.json_response({"status": "error", "message": "JSON inválido"}, status=400) except Exception as e: print(f"Erro ao lidar com a mensagem MCP: {e}") return web.json_response({"status": "error", "message": str(e)}, status=500) async def main(): app = web.Application() app.add_routes([ web.get('/sse', sse_handler), web.post('/mcp', handle_mcp_message), ]) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, 'localhost', 8080) await site.start() print("Servidor iniciado em http://localhost:8080") try: await asyncio.Future() # Executa para sempre finally: await runner.cleanup() if __name__ == "__main__": asyncio.run(main()) ``` **Tradução das explicações:** * **Dependências:** Usa `aiohttp` para tratamento web assíncrono, o que é crucial para SSE. Instale com `pip install aiohttp`. * **Assíncrono:** O código é totalmente assíncrono usando `async` e `await`, tornando-o não bloqueante e capaz de lidar com múltiplos clientes concorrentemente. Isso é *essencial* para um servidor SSE. * **Handler SSE (`sse_handler`):** * Define os cabeçalhos corretos para SSE: `Content-Type: text/event-stream`, `Cache-Control: no-cache` e `Connection: keep-alive`. Estes são *obrigatórios* para que o SSE funcione corretamente nos navegadores. * `web.StreamResponse` é usado para transmitir dados para o cliente. * `await response.prepare(request)`: Prepara a resposta para envio. * **Rastreamento de Cliente:** A lista `clients` armazena tuplas de `(client_id, response)`. É assim que o servidor rastreia os clientes conectados para que possa enviar mensagens posteriormente. Um `uuid` é usado para gerar IDs de cliente exclusivos. * **Keep-Alive:** O loop `async for msg in request.content.iter_any(): pass` é *crítico*. Ele mantém a conexão SSE ativa. Sem ele, a conexão será fechada após um curto período. Ele lê todos os dados de entrada (que ignoramos neste exemplo, mas você pode usá-lo para comunicação cliente-servidor, se necessário). * **Tratamento de Erros:** Inclui blocos `try...except...finally` para lidar com desconexões de clientes de forma elegante (tanto desconexões normais quanto desconexões devido a erros). O bloco `finally` garante que o cliente seja removido da lista `clients` e que a resposta seja fechada. * **Classe de Mensagem MCP (`MCPMessage`):** * Encapsula a estrutura de uma mensagem MCP (tipo, dados, ID). * `to_json()`: Serializa a mensagem para JSON para envio pela rede. * `from_json()`: Desserializa uma string JSON de volta para um objeto `MCPMessage`. Inclui tratamento de erros básico para JSON inválido. * **Enviando Mensagens (`send_message_to_client`, `broadcast_message`):** * `send_message_to_client` envia uma mensagem para um cliente específico, identificado pelo seu `client_id`. * `broadcast_message` envia uma mensagem para *todos* os clientes conectados. * **Formato SSE:** As mensagens são formatadas corretamente para SSE: `data: {json_data}\n\n`. O prefixo `data:` e a nova linha dupla (`\n\n`) são *obrigatórios* pelo protocolo SSE. * `await response.write(...)`: Escreve os dados no fluxo de resposta do cliente. Os dados devem ser codificados como bytes UTF-8. * `await response.drain()`: Isso é *importante* para o desempenho. Garante que os dados sejam realmente enviados para o cliente e não fiquem apenas em um buffer. * **Handler de Mensagem MCP (`handle_mcp_message`):** * Lida com requisições HTTP POST recebidas no endpoint `/mcp`. É aqui que os clientes enviam mensagens MCP para o servidor. * Analisa os dados JSON do corpo da requisição. * Desserializa o JSON em um objeto `MCPMessage` usando `MCPMessage.from_json()`. * **Processamento de Mensagens:** Inclui código de exemplo para processar diferentes tipos de mensagens ("ping", "command"). Você substituiria isso pela sua lógica MCP real. * **Tratamento de Erros:** Inclui tratamento de erros para JSON inválido e outras exceções. * **Resposta:** Envia uma resposta JSON de volta para o cliente indicando o status do processamento da mensagem. * **Função Principal (`main`):** * Cria um `aiohttp.web.Application`. * Adiciona rotas para o endpoint SSE (`/sse`) e o endpoint de mensagem MCP (`/mcp`). * Inicia o servidor web em `localhost:8080`. * Usa `asyncio.Future()` para manter o servidor em execução indefinidamente. * Inclui um bloco `finally` para limpar os recursos quando o servidor é interrompido. **Como Executar:** 1. **Salvar:** Salve o código como um arquivo Python (por exemplo, `mcp_server.py`). 2. **Instalar `aiohttp`:** `pip install aiohttp` 3. **Executar:** `python mcp_server.py` **Exemplo de Cliente (JavaScript/HTML):** (O código do cliente JavaScript/HTML permanece o mesmo, pois não precisa de tradução.) **Considerações Importantes:** * **Segurança:** Este é um exemplo *muito básico* e *não* inclui nenhuma medida de segurança. Em uma aplicação do mundo real, você precisaria implementar autenticação, autorização e validação de entrada para evitar vulnerabilidades de segurança. Seja especialmente cuidadoso ao executar comandos recebidos de clientes. * **Tratamento de Erros:** O tratamento de erros neste exemplo é mínimo. Você deve adicionar um tratamento de erros mais robusto para capturar e lidar com possíveis erros de forma elegante. * **Serialização de Dados:** JSON é usado para serialização de dados neste exemplo. Você pode usar outros formatos, como Protocol Buffers ou MessagePack, para melhor desempenho ou estruturas de dados mais complexas. * **Escalabilidade:** Para aplicações de alta escalabilidade, você pode precisar usar uma fila de mensagens ou um sistema pub/sub mais sofisticado. * **Comunicação Cliente-Servidor:** Este exemplo se concentra principalmente na comunicação servidor-cliente (via SSE). Se você precisar de uma comunicação cliente-servidor mais robusta, você pode considerar usar WebSockets em vez de SSE. Você pode enviar dados do cliente para o servidor através do endpoint POST `/mcp`. * **IDs de Mensagem:** O uso de UUIDs para IDs de mensagem permite rastrear mensagens e correlacionar requisições com respostas. Isso é especialmente útil para comunicação assíncrona. * **Reconexão:** Clientes SSE normalmente lidam com a reconexão automática se a conexão for perdida. No entanto, você pode querer adicionar lógica de reconexão explícita ao seu código de cliente para lidar com cenários mais complexos. Este exemplo abrangente fornece uma base sólida para construir seu próprio servidor MCP usando Python e SSE. Lembre-se de adaptá-lo às suas necessidades específicas e adicionar as medidas de segurança e tratamento de erros necessárias.

ExpoSnap

Enables AI assistants to view and analyze screenshots from React Native/Expo applications for AI-powered mobile UI development. Integrates with Claude, Cursor, VS Code and other MCP-compatible editors.

PBIXRay MCP Server

Espelho de

Zoom API MCP Server

Enables interaction with Zoom services through the Zoom API. Provides access to meeting management, user administration, and other Zoom platform features through natural language commands.

ExcelReadMCP

Enables reading and searching Excel files through MCP-compatible clients. Provides tools to retrieve workbook metadata, read sheet contents, and search across all sheets using absolute file paths.

CTF MCP Server

Exposes common CTF and cybersecurity tools (crypto, forensics, malware analysis, steganography, reverse engineering, pwn, OSINT) so LLMs can help solve capture-the-flag challenges in a controlled lab environment.

HotNews MCP Server

Provides real-time hot trending topics and heat indices from nine major Chinese social media and news platforms including Weibo, Zhihu, and Bilibili. It enables users to fetch markdown-formatted news summaries and clickable links via the get_hot_news tool.

Outlook MCP Server

Connects Claude to Microsoft Outlook through the Microsoft Graph API, enabling email management (list, search, read, send) and calendar operations (list, create, accept, decline, delete events) via OAuth 2.0 authentication.

chainlist-mcp

chainlist-mcp

Node Omnibus MCP Server

Espelho de

Remote MCP Server Authless

A template for deploying a remote Model Context Protocol server on Cloudflare Workers without authentication. It enables users to build custom tools and expose them to remote clients like Claude Desktop and the Cloudflare AI Playground using Server-Sent Events (SSE).

Derisk

Sistemas de Inteligência de Risco Nativos de IA