Discover Awesome MCP Servers

MCP Server Enhanced SSH

Um servidor SSH robusto que facilita a execução segura de comandos remotos com gerenciamento de sessão TMUX, suporte a múltiplas janelas e recuperação inteligente de sessão para uma interação IA-humano aprimorada.

Mozilla Readability Parser MCP Server

Uma implementação em Python de um servidor MCP que extrai conteúdo de páginas web, remove anúncios e elementos não essenciais, e transforma-o em Markdown limpo, otimizado para LLMs.

CockroachDB MCP Server

Conecta-se a instâncias do CockroachDB e expõe as estruturas do banco de dados como recursos, permitindo a execução de consultas SQL e a análise através da interface do Claude.

mcp-server-google-analytics

Uma implementação de servidor MCP para acessar dados do Google Analytics 4 (GA4), construída usando o SDK TypeScript do Model Context Protocol.

X MCP Server

Servidor para integração com o X (Twitter) que oferece ferramentas para ler sua timeline e interagir com tweets. Projetado para uso com o Claude desktop.

MCP Stripe Server

Um servidor que se integra ao Stripe para lidar com pagamentos, clientes e reembolsos através do Protocolo de Contexto de Modelo, fornecendo uma API segura para gerenciar transações financeiras.

MCP Blockchain Server

Um sistema seguro que permite que assistentes de IA interajam com dados de blockchain e preparem transações, garantindo que os usuários mantenham controle exclusivo sobre suas chaves privadas e assinatura de transações.

Playwright Server MCP

O servidor oferece ferramentas para automação web usando Playwright, permitindo navegação, interação e execução de JavaScript em páginas da web, e suporta armazenamento de notas com capacidades de sumarização.

WolframAlpha LLM MCP Server

Permite consultar a API LLM do WolframAlpha para perguntas em linguagem natural, fornecendo respostas estruturadas e simplificadas, otimizadas para o consumo por LLMs.

Nostr MCP Server

Um servidor de Protocolo de Contexto de Modelo (MCP) que permite que modelos de IA interajam com a rede Nostr, facilitando a publicação de notas e a interação com o protocolo de liberdade de expressão.

MCP Security Audit Server

Audita as dependências de pacotes npm em busca de vulnerabilidades de segurança, fornecendo relatórios detalhados e recomendações de correção com integração MCP.

GitLab MCP Server

Uma implementação de servidor personalizada que permite que assistentes de IA interajam com repositórios GitLab, fornecendo capacidades para pesquisar, buscar arquivos, criar/atualizar conteúdo e gerenciar issues e merge requests.

MCP Intercom Server

Fornece acesso a conversas e chats do Intercom através do Protocolo de Contexto do Modelo, permitindo que LLMs consultem e analisem conversas do Intercom com várias opções de filtragem.

MCP Server for Replicate

Uma implementação de servidor FastMCP que fornece uma interface padronizada para acessar modelos de IA hospedados na API da Replicate, atualmente suportando geração de imagens com parâmetros personalizáveis.

Code Research MCP Server

Facilita a busca e o acesso a recursos de programação em plataformas como Stack Overflow, MDN, GitHub, npm e PyPI, auxiliando LLMs a encontrar exemplos de código e documentação.

Seq MCP Server

O Seq MCP Server permite a interação com os endpoints da API do Seq para registro e monitoramento, fornecendo ferramentas para gerenciar sinais, eventos e alertas com extensas opções de filtragem e configuração.

Barnsworthburning MCP

Um servidor de Protocolo de Contexto de Modelo que permite pesquisar conteúdo de barnsworthburning.net diretamente através de clientes de IA compatíveis, como o Claude para Desktop.

BioMCP

Um servidor de Protocolo de Contexto de Modelo que aprimora modelos de linguagem com capacidades de análise de estrutura de proteínas, permitindo análises detalhadas de sítios ativos e buscas de proteínas relacionadas a doenças através de bancos de dados de proteínas estabelecidos.

MCP Server Template for Cursor IDE

Absolutely! Here's a template and guide for creating custom Cursor IDE tools using the Model Context Protocol (MCP), with instructions for deploying your MCP server to Heroku and connecting it to Cursor: **Template Structure** ```python # main.py (Your MCP Server) import os import json from typing import Dict, Any, List from fastapi import FastAPI, Request, HTTPException from fastapi.middleware.cors import CORSMiddleware import uvicorn # --- Configuration --- PORT = int(os.environ.get("PORT", 8000)) # Heroku uses PORT env var MODEL_NAME = "MyCustomTool" # Unique name for your tool DESCRIPTION = "A custom tool for Cursor IDE." ENDPOINT = "/my_tool" # Endpoint for Cursor to send requests # --- FastAPI Setup --- app = FastAPI(title=MODEL_NAME, description=DESCRIPTION) # CORS (Important for web-based IDEs like Cursor) app.add_middleware( CORSMiddleware, allow_origins=["*"], # Adjust for production! allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) # --- MCP Endpoints --- @app.post(ENDPOINT + "/info") async def get_info() -> Dict[str, Any]: """Returns information about the tool.""" return { "model_name": MODEL_NAME, "description": DESCRIPTION, "stream": False, # Set to True if your tool supports streaming } @app.post(ENDPOINT + "/generate") async def generate(request: Request) -> Dict[str, Any]: """Handles generation requests from Cursor.""" try: data = await request.json() prompt = data.get("prompt", "") context = data.get("context", {}) # Context from Cursor # --- Your Tool Logic Here --- # Process the prompt and context to generate a response. # Example: response_text = f"You asked: {prompt}\nContext: {context}" return {"response": response_text} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) # --- Main Execution --- if __name__ == "__main__": uvicorn.run(app, host="0.0.0.0", port=PORT) ``` **Explanation** 1. **Imports:** Essential libraries for FastAPI, JSON handling, and environment variables. 2. **Configuration:** * `PORT`: Gets the port from the environment (Heroku sets this). Defaults to 8000 for local testing. * `MODEL_NAME`: A unique name for your tool. This is how Cursor identifies it. * `DESCRIPTION`: A brief description of your tool. * `ENDPOINT`: The URL path where Cursor will send requests. Make sure this is unique. 3. **FastAPI Setup:** * Creates a FastAPI app. * **CORS:** Crucially important! Cursor runs in a web browser, so you need to enable CORS to allow requests from Cursor's origin. In production, replace `"*"` with the specific origin of your Cursor instance. 4. **MCP Endpoints:** * `/info`: Returns metadata about your tool. `stream` indicates whether your tool supports streaming responses (more advanced). * `/generate`: The main endpoint for handling generation requests. * It extracts the `prompt` and `context` from the request body. * **Your Tool Logic:** This is where you implement the core functionality of your tool. Process the prompt and context to generate a response. * Returns a JSON response with the `response` field containing the generated text. 5. **Main Execution:** Starts the FastAPI server using Uvicorn. **Steps to Deploy to Heroku** 1. **Create a Heroku Account:** If you don't have one, sign up at [https://www.heroku.com/](https://www.heroku.com/). 2. **Install the Heroku CLI:** Follow the instructions on the Heroku website to install the Heroku Command Line Interface (CLI). 3. **Create a Heroku App:** ```bash heroku create my-cursor-tool # Replace with your desired app name ``` 4. **Create a `requirements.txt` File:** List all the Python dependencies your project needs: ``` fastapi uvicorn[standard] python-multipart # Required for form data (if needed) ``` 5. **Create a `Procfile`:** This tells Heroku how to run your app. Create a file named `Procfile` (no extension) with the following content: ``` web: uvicorn main:app --host=0.0.0.0 --port=$PORT ``` 6. **Deploy to Heroku:** ```bash git init git add . git commit -m "Initial commit" heroku git:remote -a my-cursor-tool # Replace with your app name git push heroku main ``` 7. **Check Logs:** After deployment, check the Heroku logs to ensure everything is running correctly: ```bash heroku logs --tail ``` **Connecting to Cursor IDE** 1. **Get Your Heroku App URL:** After deployment, Heroku will provide a URL for your app (e.g., `https://my-cursor-tool.herokuapp.com`). 2. **Configure Cursor:** * Open Cursor IDE. * Go to Settings (usually Cmd + , or Ctrl + ,). * Find the "Model Context Protocol" section. * Click "Add Model". * Enter the following: * **Model Name:** The `MODEL_NAME` you defined in your code (e.g., `MyCustomTool`). * **Endpoint:** The full URL of your Heroku app, including the endpoint path (e.g., `https://my-cursor-tool.herokuapp.com/my_tool`). 3. **Test Your Tool:** In Cursor, try using your custom tool. You should be able to access it through the command palette or other Cursor features that support MCP. **Important Considerations** * **Security:** In a production environment, you should implement proper authentication and authorization to protect your MCP server. Consider using API keys or other security measures. * **Error Handling:** Implement robust error handling in your tool logic to gracefully handle unexpected situations. * **Rate Limiting:** If your tool is resource-intensive, consider implementing rate limiting to prevent abuse. * **Context:** Pay close attention to the `context` data that Cursor sends. This can provide valuable information about the current code, file, or project. * **Streaming:** If you want to support streaming responses, you'll need to modify your code to use Server-Sent Events (SSE) or WebSockets. * **Heroku Free Tier:** Be aware that the Heroku free tier has limitations. Your app may sleep if it's not used for a while. Consider upgrading to a paid plan for production use. * **Environment Variables:** Use environment variables for sensitive information like API keys or database credentials. You can set environment variables in the Heroku dashboard. **Example Tool Logic** Here's a more concrete example of tool logic that uses the context to provide code suggestions: ```python @app.post(ENDPOINT + "/generate") async def generate(request: Request) -> Dict[str, Any]: try: data = await request.json() prompt = data.get("prompt", "") context = data.get("context", {}) current_file = context.get("currentFile", {}) file_content = current_file.get("content", "") cursor_position = context.get("cursorPosition", {}) line = cursor_position.get("line", 0) character = cursor_position.get("character", 0) # Example: Suggest a function name based on the current line if "def " in file_content.splitlines()[line]: response_text = "Perhaps you should name this function 'process_data'?" else: response_text = "I'm ready to help with your coding!" return {"response": response_text} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) ``` **Translation to Portuguese** Here's a translation of the key parts of the explanation: **Tradução para Português** **Estrutura do Modelo** (A estrutura do código em Python permanece a mesma) **Explicação** 1. **Importações:** Bibliotecas essenciais para FastAPI, manipulação de JSON e variáveis de ambiente. 2. **Configuração:** * `PORT`: Obtém a porta do ambiente (Heroku define isso). O padrão é 8000 para testes locais. * `MODEL_NAME`: Um nome único para sua ferramenta. É assim que o Cursor a identifica. * `DESCRIPTION`: Uma breve descrição da sua ferramenta. * `ENDPOINT`: O caminho da URL onde o Cursor enviará as solicitações. Certifique-se de que seja único. 3. **Configuração do FastAPI:** * Cria um aplicativo FastAPI. * **CORS:** Crucialmente importante! O Cursor é executado em um navegador da web, então você precisa habilitar o CORS para permitir solicitações da origem do Cursor. Em produção, substitua `"*"` pela origem específica da sua instância do Cursor. 4. **Endpoints MCP:** * `/info`: Retorna metadados sobre sua ferramenta. `stream` indica se sua ferramenta suporta respostas de streaming (mais avançado). * `/generate`: O endpoint principal para lidar com solicitações de geração. * Ele extrai o `prompt` e o `context` do corpo da solicitação. * **Lógica da sua Ferramenta:** É aqui que você implementa a funcionalidade principal da sua ferramenta. Processe o prompt e o contexto para gerar uma resposta. * Retorna uma resposta JSON com o campo `response` contendo o texto gerado. 5. **Execução Principal:** Inicia o servidor FastAPI usando Uvicorn. **Passos para Implantar no Heroku** 1. **Crie uma Conta Heroku:** Se você não tiver uma, inscreva-se em [https://www.heroku.com/](https://www.heroku.com/). 2. **Instale o Heroku CLI:** Siga as instruções no site do Heroku para instalar a Interface de Linha de Comando (CLI) do Heroku. 3. **Crie um Aplicativo Heroku:** ```bash heroku create my-cursor-tool # Substitua pelo nome desejado do seu aplicativo ``` 4. **Crie um Arquivo `requirements.txt`:** Liste todas as dependências Python que seu projeto precisa: ``` fastapi uvicorn[standard] python-multipart # Necessário para dados de formulário (se necessário) ``` 5. **Crie um `Procfile`:** Isso diz ao Heroku como executar seu aplicativo. Crie um arquivo chamado `Procfile` (sem extensão) com o seguinte conteúdo: ``` web: uvicorn main:app --host=0.0.0.0 --port=$PORT ``` 6. **Implante no Heroku:** ```bash git init git add . git commit -m "Commit inicial" heroku git:remote -a my-cursor-tool # Substitua pelo nome do seu aplicativo git push heroku main ``` 7. **Verifique os Logs:** Após a implantação, verifique os logs do Heroku para garantir que tudo esteja funcionando corretamente: ```bash heroku logs --tail ``` **Conectando ao Cursor IDE** 1. **Obtenha o URL do seu Aplicativo Heroku:** Após a implantação, o Heroku fornecerá um URL para seu aplicativo (por exemplo, `https://my-cursor-tool.herokuapp.com`). 2. **Configure o Cursor:** * Abra o Cursor IDE. * Vá para Configurações (geralmente Cmd + , ou Ctrl + ,). * Encontre a seção "Model Context Protocol". * Clique em "Add Model". * Insira o seguinte: * **Model Name:** O `MODEL_NAME` que você definiu em seu código (por exemplo, `MyCustomTool`). * **Endpoint:** O URL completo do seu aplicativo Heroku, incluindo o caminho do endpoint (por exemplo, `https://my-cursor-tool.herokuapp.com/my_tool`). 3. **Teste sua Ferramenta:** No Cursor, tente usar sua ferramenta personalizada. Você deve conseguir acessá-la através da paleta de comandos ou outros recursos do Cursor que suportam MCP. **Considerações Importantes** * **Segurança:** Em um ambiente de produção, você deve implementar autenticação e autorização adequadas para proteger seu servidor MCP. Considere usar chaves de API ou outras medidas de segurança. * **Tratamento de Erros:** Implemente um tratamento de erros robusto na lógica da sua ferramenta para lidar normalmente com situações inesperadas. * **Limitação de Taxa:** Se sua ferramenta for intensiva em recursos, considere implementar a limitação de taxa para evitar abusos. * **Contexto:** Preste muita atenção aos dados de `context` que o Cursor envia. Isso pode fornecer informações valiosas sobre o código, arquivo ou projeto atual. * **Streaming:** Se você deseja suportar respostas de streaming, você precisará modificar seu código para usar Server-Sent Events (SSE) ou WebSockets. * **Nível Gratuito do Heroku:** Esteja ciente de que o nível gratuito do Heroku tem limitações. Seu aplicativo pode dormir se não for usado por um tempo. Considere atualizar para um plano pago para uso em produção. * **Variáveis de Ambiente:** Use variáveis de ambiente para informações confidenciais, como chaves de API ou credenciais de banco de dados. Você pode definir variáveis de ambiente no painel do Heroku. I hope this comprehensive template and guide helps you create amazing custom tools for Cursor IDE! Let me know if you have any other questions.

Redmine MCP Server

Um servidor de Protocolo de Contexto de Modelo para interagir com o Redmine usando sua API REST, permitindo o gerenciamento de tickets, projetos e dados de usuário através da integração com LLMs.

mcp-server-tmdb

Integra-se com a API do The Movie Database (TMDB) para fornecer informações sobre filmes, capacidades de busca e recomendações.

Bitcoin MCP Server

Facilita a interação com a rede Bitcoin através do Protocolo de Contexto do Modelo, permitindo a geração de chaves, validação de endereços, decodificação de transações e recuperação de dados da blockchain.

PyTorch HUD MCP Server

Fornece acesso a dados de análise de CI/CD do PyTorch, incluindo fluxos de trabalho, tarefas, execuções de teste e análise de logs, através de uma interface MCP.

KNMI Weather MCP

A FastMCP server that provides real-time weather data from KNMI weather stations, allowing users to access temperature, humidity, wind speed, and other weather metrics for any location in the Netherlands through natural language queries.

World Bank MCP Server

Permite que assistentes de IA interajam com a API de dados abertos do Banco Mundial, possibilitando a listagem e análise de indicadores em todos os países disponíveis.

mcp-github

Servidor MCP do GitHub da Anthropic, só que melhor. Suporte para mais endpoints. Incluindo lançamentos e tags, revisões de pull requests, status, limite de taxa, gists, projetos, pacotes e até mesmo diffs de pull requests. Destinado a ser usado com a API MCP da MissionSquad para gerenciamento de segredos (ou seja, seu token de acesso).

emqx-mcp-server

Uma implementação de servidor de Protocolo de Contexto de Modelo (MCP) que fornece interação com o broker MQTT EMQX.

mcp-server-birdstats

Okay, here's how you can cross-reference your BirdNET-Pi data with eBird observations using natural language, along with some considerations and potential approaches: **Understanding the Goal** The core idea is to compare what your BirdNET-Pi device *detected* with what human birders *observed* in the same area and time frame. This helps you: * **Validate BirdNET-Pi's Accuracy:** See how well the AI agrees with human observations. * **Identify Missed Detections:** Discover species present that BirdNET-Pi didn't pick up. * **Understand Local Bird Activity:** Gain a more complete picture of bird presence and behavior in your area. * **Improve BirdNET-Pi Setup:** Adjust settings or location based on discrepancies. **General Steps (Conceptual)** 1. **Data Extraction:** * **BirdNET-Pi Data:** Get the date, time, location (latitude/longitude), and species detections from your BirdNET-Pi logs. You'll likely need to parse the log files. * **eBird Data:** Use the eBird API (Application Programming Interface) or download eBird data for your region. You'll need an eBird account and API key. The data will include date, time, location, species, and observer information. 2. **Spatial and Temporal Filtering:** * **Define a Search Radius:** Determine how close an eBird observation needs to be to your BirdNET-Pi location to be considered a match (e.g., within 1 km, 5 km). * **Define a Time Window:** Determine how close in time an eBird observation needs to be to your BirdNET-Pi detection (e.g., within 1 hour, 1 day). 3. **Comparison and Analysis:** * **Match Detections:** For each BirdNET-Pi detection, find eBird observations within the defined radius and time window. * **Identify Agreements:** List species detected by both BirdNET-Pi and eBird. * **Identify Discrepancies:** * Species detected by BirdNET-Pi but *not* reported on eBird within the search area/timeframe. * Species reported on eBird but *not* detected by BirdNET-Pi within the search area/timeframe. 4. **Interpretation:** * Consider factors that might explain discrepancies: * **BirdNET-Pi Errors:** Misidentification by the AI. * **eBird Observer Skill:** Varying levels of expertise among eBird users. * **Bird Behavior:** Birds may be present but not vocalizing. * **Habitat Differences:** eBird observations might be in slightly different habitats than your BirdNET-Pi location. * **Rarity:** Rare birds might be missed by BirdNET-Pi. * **Detection Range:** BirdNET-Pi has a limited detection range. **Natural Language Examples (How you might phrase your queries/analysis)** Here are examples of how you might express your analysis in natural language: * "For all BirdNET-Pi detections on July 15, 2024, within a 1-kilometer radius of my device, compare the detected species to eBird checklists submitted on the same day." * "Show me all instances where BirdNET-Pi detected a Northern Cardinal, but no eBird checklist within 500 meters and 2 hours of that detection reported a Northern Cardinal." * "What species were reported on eBird within a 2-kilometer radius of my BirdNET-Pi location during the month of June that BirdNET-Pi never detected?" * "Calculate the percentage of times BirdNET-Pi and eBird agreed on the presence of American Robins within a 1-day window and a 5-kilometer radius." * "List the top 5 species most frequently detected by BirdNET-Pi that were *not* reported on eBird within a 1-kilometer radius and a 1-hour window." * "Analyze the correlation between the confidence score of BirdNET-Pi detections and the likelihood of those species being reported on eBird within a 5-kilometer radius." * "Identify any rare or unusual species detected by BirdNET-Pi that were not confirmed by eBird observations in the surrounding area within a week." **Technical Considerations** * **Programming:** You'll likely need to use a programming language like Python to automate this process. Python has libraries for: * Data manipulation (Pandas) * Spatial calculations (GeoPandas, Shapely) * API interaction (Requests) * Date/time handling (datetime) * **eBird API:** Familiarize yourself with the eBird API documentation. You'll need to register for an API key. Be mindful of API usage limits. * **Data Storage:** Consider storing your BirdNET-Pi data and eBird data in a database (e.g., SQLite, PostgreSQL) for easier querying and analysis. * **Geospatial Calculations:** Use appropriate geospatial functions to calculate distances between BirdNET-Pi locations and eBird observation points. Be aware of coordinate systems (latitude/longitude). * **Error Handling:** Implement robust error handling to deal with potential issues like API errors, missing data, or invalid data formats. **Example Python Snippet (Illustrative - Requires Adaptation)** ```python import pandas as pd import requests from datetime import datetime, timedelta from geopy.distance import geodesic # For calculating distances # --- Configuration --- BIRDNET_PI_LOG_FILE = "your_birdnet_pi_log.txt" # Replace with your log file EBIRD_API_KEY = "YOUR_EBIRD_API_KEY" # Replace with your eBird API key LATITUDE = 34.0522 # Replace with your BirdNET-Pi latitude LONGITUDE = -118.2437 # Replace with your BirdNET-Pi longitude SEARCH_RADIUS_KM = 1 # Search radius in kilometers TIME_WINDOW_HOURS = 2 # Time window in hours # --- Function to parse BirdNET-Pi log (Adapt to your log format) --- def parse_birdnet_log(log_file): # This is a placeholder - you'll need to adapt this to your log file format data = [] with open(log_file, 'r') as f: for line in f: if "Detected" in line: # Example: Adapt this to your log's structure try: date_str = line.split(" ")[0] # Example: Extract date time_str = line.split(" ")[1] # Example: Extract time species = line.split("Detected: ")[1].split(" ")[0] # Example: Extract species confidence = float(line.split("Confidence: ")[1].split(" ")[0]) # Example: Extract confidence datetime_obj = datetime.strptime(f"{date_str} {time_str}", "%Y-%m-%d %H:%M:%S") # Adapt format data.append({"datetime": datetime_obj, "species": species, "confidence": confidence}) except: pass return pd.DataFrame(data) # --- Function to fetch eBird data (Adapt to your needs) --- def get_ebird_data(latitude, longitude, date, api_key, radius=1): date_str = date.strftime("%Y-%m-%d") url = f"https://api.ebird.org/v2/data/obs/geo/recent?lat={latitude}&lng={longitude}&dist={radius}&back=1&fmt=json" # Example URL headers = {"X-eBirdAPIToken": api_key} response = requests.get(url, headers=headers) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) return response.json() # --- Main Script --- birdnet_data = parse_birdnet_log(BIRDNET_PI_LOG_FILE) for index, row in birdnet_data.iterrows(): birdnet_datetime = row['datetime'] birdnet_species = row['species'] # Fetch eBird data for the same day try: ebird_data = get_ebird_data(LATITUDE, LONGITUDE, birdnet_datetime.date(), EBIRD_API_KEY, SEARCH_RADIUS_KM) except requests.exceptions.HTTPError as e: print(f"Error fetching eBird data: {e}") continue # Filter eBird data by time window matching_ebird_observations = [] for obs in ebird_data: obs_datetime = datetime.fromtimestamp(obs['obsDt']/1000) # Convert eBird timestamp to datetime time_difference = abs(birdnet_datetime - obs_datetime) if time_difference <= timedelta(hours=TIME_WINDOW_HOURS): matching_ebird_observations.append(obs['sciName']) # Use scientific name for comparison # Compare BirdNET-Pi and eBird if birdnet_species in matching_ebird_observations: print(f"BirdNET-Pi and eBird agree: {birdnet_species} detected on {birdnet_datetime}") else: print(f"BirdNET-Pi detected {birdnet_species} on {birdnet_datetime}, but not found on eBird within the search area/timeframe.") # You can add more analysis here, such as identifying species reported on eBird # that BirdNET-Pi missed. ``` **Important Notes:** * **Adapt the Code:** The Python code is a starting point. You *must* adapt it to your specific BirdNET-Pi log file format and your desired analysis. * **Error Handling:** The code includes basic error handling, but you should add more robust error handling for production use. * **API Limits:** Be aware of eBird API usage limits and implement strategies to avoid exceeding them (e.g., caching data). * **Data Quality:** Remember that both BirdNET-Pi and eBird data have limitations. Interpret the results with caution. * **Scientific Names:** Use scientific names for species comparisons to avoid ambiguity. You may need to map common names from BirdNET-Pi to scientific names. **Translation to Portuguese:** Here's a translation of the general steps and natural language examples: **Passos Gerais (Conceitual)** 1. **Extração de Dados:** * **Dados do BirdNET-Pi:** Obtenha a data, hora, localização (latitude/longitude) e as espécies detectadas dos seus logs do BirdNET-Pi. Provavelmente, você precisará analisar os arquivos de log. * **Dados do eBird:** Use a API do eBird (Interface de Programação de Aplicativos) ou baixe os dados do eBird para sua região. Você precisará de uma conta eBird e uma chave de API. Os dados incluirão data, hora, localização, espécies e informações do observador. 2. **Filtragem Espacial e Temporal:** * **Defina um Raio de Busca:** Determine a proximidade que uma observação do eBird precisa ter da sua localização do BirdNET-Pi para ser considerada uma correspondência (por exemplo, dentro de 1 km, 5 km). * **Defina uma Janela de Tempo:** Determine a proximidade no tempo que uma observação do eBird precisa ter da sua detecção do BirdNET-Pi (por exemplo, dentro de 1 hora, 1 dia). 3. **Comparação e Análise:** * **Combine Detecções:** Para cada detecção do BirdNET-Pi, encontre observações do eBird dentro do raio e janela de tempo definidos. * **Identifique Concordâncias:** Liste as espécies detectadas tanto pelo BirdNET-Pi quanto pelo eBird. * **Identifique Discrepâncias:** * Espécies detectadas pelo BirdNET-Pi, mas *não* relatadas no eBird dentro da área/período de busca. * Espécies relatadas no eBird, mas *não* detectadas pelo BirdNET-Pi dentro da área/período de busca. 4. **Interpretação:** * Considere fatores que podem explicar as discrepâncias: * **Erros do BirdNET-Pi:** Identificação incorreta pela IA. * **Habilidade do Observador do eBird:** Níveis variados de experiência entre os usuários do eBird. * **Comportamento das Aves:** As aves podem estar presentes, mas não vocalizando. * **Diferenças de Habitat:** As observações do eBird podem estar em habitats ligeiramente diferentes da sua localização do BirdNET-Pi. * **Raridade:** Aves raras podem não ser detectadas pelo BirdNET-Pi. * **Alcance de Detecção:** O BirdNET-Pi tem um alcance de detecção limitado. **Exemplos de Linguagem Natural (Como você poderia formular suas consultas/análises)** Aqui estão exemplos de como você poderia expressar sua análise em linguagem natural: * "Para todas as detecções do BirdNET-Pi em 15 de julho de 2024, dentro de um raio de 1 quilômetro do meu dispositivo, compare as espécies detectadas com as listas de verificação do eBird enviadas no mesmo dia." * "Mostre-me todas as instâncias em que o BirdNET-Pi detectou um Cardeal-do-norte, mas nenhuma lista de verificação do eBird dentro de 500 metros e 2 horas dessa detecção relatou um Cardeal-do-norte." * "Quais espécies foram relatadas no eBird dentro de um raio de 2 quilômetros da minha localização do BirdNET-Pi durante o mês de junho que o BirdNET-Pi nunca detectou?" * "Calcule a porcentagem de vezes que o BirdNET-Pi e o eBird concordaram com a presença de Tordos-americanos dentro de uma janela de 1 dia e um raio de 5 quilômetros." * "Liste as 5 principais espécies mais frequentemente detectadas pelo BirdNET-Pi que *não* foram relatadas no eBird dentro de um raio de 1 quilômetro e uma janela de 1 hora." * "Analise a correlação entre a pontuação de confiança das detecções do BirdNET-Pi e a probabilidade de essas espécies serem relatadas no eBird dentro de um raio de 5 quilômetros." * "Identifique quaisquer espécies raras ou incomuns detectadas pelo BirdNET-Pi que não foram confirmadas por observações do eBird na área circundante dentro de uma semana." Remember to adapt the code and analysis to your specific needs and data. Good luck!

MongoDB Lens

Servidor MCP completo para análise de banco de dados MongoDB.

MCP Server Firecrawl

Um servidor que oferece recursos de web scraping e busca inteligente de conteúdo usando a API Firecrawl, permitindo que agentes de IA extraiam dados estruturados de sites e realizem buscas de conteúdo.