Discover Awesome MCP Servers

Brave Search

Web and local search using Brave's Search API

MCP Python Server

A Python-based implementation of the Model Context Protocol that enables communication between a model context management server and client through a request-response architecture.

WordPress MCP Server

Espelho de

Instantly MCP Server

Fornece acesso à API v2 do Instantly para funcionalidades de campanha de e-mail e gerenciamento de leads.

mcp-server-template-ic

Servidor MCP com conexão à carteira IC.

manim-mcp-server

I understand you're asking me to create animations similar to those made by 3Blue1Brown, using only a single prompt. Unfortunately, I can't directly *generate* those animations for you. I am a text-based AI, and creating complex visual animations requires specialized software and coding skills. However, I *can* provide you with a single, comprehensive prompt that you can use with an AI image generation tool (like DALL-E 2, Midjourney, or Stable Diffusion) or, more effectively, with a code-based animation library like Manim (which is what 3Blue1Brown uses). This prompt will focus on the *style* and *content* of a typical 3Blue1Brown animation. Here's the prompt: **Prompt:** "Create a mathematical animation in the style of 3Blue1Brown. The animation should visually explain the concept of [**INSERT MATHEMATICAL CONCEPT HERE, e.g., 'the derivative', 'eigenvectors', 'Fourier transform'**]. Use a clean, minimalist aesthetic with a focus on clarity and intuitive understanding. Employ smooth, fluid transitions and transformations to illustrate the underlying principles. The color palette should be primarily blues, greens, and grays, with occasional pops of yellow or orange to highlight key elements. Include dynamically updating graphs, geometric shapes, and vector representations. The animation should emphasize the *process* of the mathematical concept, not just the final result. Focus on visual metaphors and analogies to make the concept accessible. The overall tone should be educational, engaging, and visually appealing. The animation should be suitable for a YouTube video explaining [**REPEAT MATHEMATICAL CONCEPT HERE**] to a general audience with some mathematical background. Consider incorporating elements like: [**CHOOSE RELEVANT ELEMENTS, e.g., 'a moving point on a curve', 'rotating vectors', 'area under a curve', 'frequency domain representation'**]. The animation should be approximately [**SPECIFY DURATION, e.g., '10 seconds', '30 seconds'**] long and focus on [**SPECIFIC ASPECT OF THE CONCEPT, e.g., 'the geometric interpretation', 'the relationship to integration', 'the application in signal processing'**]." **How to Use This Prompt:** 1. **Choose a Mathematical Concept:** Replace "[**INSERT MATHEMATICAL CONCEPT HERE**]" with the specific concept you want to animate (e.g., "the derivative," "linear transformations," "complex numbers"). 2. **Select Relevant Elements:** Choose the elements from the bracketed list that are most relevant to your chosen concept. You can also add your own elements. 3. **Specify Duration:** Indicate the desired length of the animation. Keep it short for initial experiments. 4. **Focus on a Specific Aspect:** Narrow down the focus of the animation to a particular aspect of the concept. 5. **Choose Your Tool:** * **AI Image Generators (DALL-E 2, Midjourney, Stable Diffusion):** These tools are better for generating *individual frames* or short, stylized clips. You'll need to combine these frames into a full animation using video editing software. You'll likely need to run the prompt multiple times, tweaking it for each frame or short sequence. * **Manim (Python Library):** This is the *ideal* tool for creating 3Blue1Brown-style animations. You'll need to learn some Python programming and the Manim syntax. The prompt above can serve as a guide for structuring your Manim code. You'll essentially be translating the prompt into Manim commands. **Important Considerations:** * **Complexity:** Creating high-quality animations like 3Blue1Brown's is a complex process. Don't expect perfect results from a single prompt, especially with AI image generators. * **Iteration:** You'll likely need to iterate on the prompt and the generated output to achieve the desired result. * **Manim Learning Curve:** Manim has a learning curve, but it's the most powerful and flexible option for creating this type of animation. 3Blue1Brown has tutorials and resources available. * **Ethical Considerations:** Be mindful of copyright and attribution if you are using elements or ideas from 3Blue1Brown's videos. This prompt provides a starting point. Experiment with different wording, elements, and tools to achieve the best results. Good luck!

AbletonMCP

A server that connects Ableton Live to Claude AI through the Model Context Protocol, enabling AI-assisted music production and direct control of Ableton Live features.

E*TRADE MCP Server

Enables comprehensive E\*TRADE integration with OAuth authentication, account management, risk calculations, watch lists, and trading operations. Includes built-in risk management guardrails, portfolio tracking, market data access, and trading validation for safe automated trading operations.

MCP Gateway

A secure bridge that allows Large Language Models (LLMs) to interact with corporate APIs and services in a controlled and contextualized manner.

Model Context Protocol Python Server

A Python implementation of the Model Context Protocol (MCP) server that enables searching and extracting information from arXiv papers, designed to be extensible with additional MCP tools.

Twilio Routes MCP Server

An MCP server that enables interaction with Twilio's Routes service through natural language, allowing users to manage SIP domains, trunks, and call routing configurations.

contentstack-mcp

contentstack-mcp

Hello Golang MCP

Aqui está a implementação mínima de um servidor MCP em Golang usando mcp-go: ```go package main import ( "context" "flag" "fmt" "log" "net" "net/http" "os" "os/signal" "syscall" "github.com/envoyproxy/go-control-plane/pkg/cache/v3" "github.com/envoyproxy/go-control-plane/pkg/server/v3" "github.com/envoyproxy/go-control-plane/pkg/test/v3" "google.golang.org/grpc" ) var ( grpcPort = flag.Int("grpc-port", 18000, "grpc port") httpPort = flag.Int("http-port", 18001, "http port") ) // Define um snapshot simples com um único recurso. func generateSnapshot() cache.Snapshot { nodeID := "test-id" // Substitua por um ID de nó real se necessário // Exemplo de um recurso RouteConfiguration. Substitua por seus próprios recursos. routeConfig := test.MakeRoute("route-example", "local_service") snapshot, err := cache.NewSnapshot( "1", // version map[cache.Type][]cache.Resource{ cache.RoutesType: {routeConfig}, }, ) if err != nil { log.Fatalf("Erro ao criar o snapshot: %v", err) } if err := snapshot.Consistent(); err != nil { log.Fatalf("Snapshot inconsistente: %v", err) } log.Printf("Snapshot aprovado: %+v\n", snapshot) return snapshot } func main() { flag.Parse() ctx := context.Background() // 1. Crie um cache. snapshotCache := cache.NewSnapshotCache(true, cache.IDHash{}, nil) // 2. Crie um servidor MCP. srv := server.NewServer(ctx, snapshotCache, &test.Callbacks{}) // 3. Crie um servidor gRPC. grpcServer := grpc.NewServer() server.RegisterServer(grpcServer, srv) // 4. Crie um servidor HTTP (opcional, para health checks ou outras APIs). httpServer := &http.Server{ Addr: fmt.Sprintf(":%d", *httpPort), Handler: http.DefaultServeMux, } // 5. Inicie os servidores em goroutines separadas. go func() { lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *grpcPort)) if err != nil { log.Fatalf("falha ao escutar: %v", err) } log.Printf("Servidor gRPC escutando em: %s", lis.Addr()) if err := grpcServer.Serve(lis); err != nil { log.Fatalf("falha ao servir o servidor gRPC: %v", err) } }() go func() { log.Printf("Servidor HTTP escutando em: %s", httpServer.Addr) if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed { log.Fatalf("falha ao servir o servidor HTTP: %v", err) } }() // 6. Defina um snapshot inicial. snapshot := generateSnapshot() if err := snapshotCache.SetSnapshot(context.Background(), "test-id", snapshot); err != nil { log.Fatalf("Erro ao definir o snapshot: %v", err) } // 7. Lide com sinais de interrupção para desligamento gracioso. signalCh := make(chan os.Signal, 1) signal.Notify(signalCh, os.Interrupt, syscall.SIGTERM) <-signalCh log.Println("Desligando...") // 8. Desligue os servidores. grpcServer.GracefulStop() if err := httpServer.Shutdown(ctx); err != nil { log.Fatalf("Erro ao desligar o servidor HTTP: %v", err) } log.Println("Servidor desligado.") } ``` **Explicação:** 1. **Importações:** Importa os pacotes necessários, incluindo `mcp-go` e pacotes relacionados do `go-control-plane`. 2. **Flags:** Define flags para configurar as portas gRPC e HTTP. 3. **`generateSnapshot()`:** Esta função cria um snapshot de configuração. É crucial entender que você precisa substituir o exemplo `test.MakeRoute` com a lógica para gerar seus próprios recursos (Clusters, Listeners, Routes, etc.) que você deseja servir através do MCP. O `nodeID` também deve ser configurado corretamente para corresponder aos IDs dos nós que estão solicitando configurações. 4. **`main()`:** - **Criação do Cache:** Cria um `SnapshotCache` para armazenar os snapshots de configuração. - **Criação do Servidor MCP:** Cria um servidor MCP usando `server.NewServer`. O terceiro argumento, `&test.Callbacks{}`, é um objeto que implementa a interface `server.Callbacks`. Você pode implementar seus próprios callbacks para lidar com eventos como conexões de clientes, solicitações de recursos e erros. Para uma implementação mínima, `&test.Callbacks{}` é suficiente. - **Criação do Servidor gRPC:** Cria um servidor gRPC e registra o servidor MCP nele. - **Criação do Servidor HTTP (Opcional):** Cria um servidor HTTP para health checks ou outras APIs. - **Início dos Servidores:** Inicia os servidores gRPC e HTTP em goroutines separadas. - **Definição do Snapshot Inicial:** Define um snapshot inicial no cache. Este é o ponto crucial onde você define a configuração que será servida aos clientes. O primeiro argumento para `SetSnapshot` é o contexto, o segundo é o ID do nó (que deve corresponder ao ID do nó que está solicitando a configuração), e o terceiro é o snapshot. - **Tratamento de Sinais:** Lida com sinais de interrupção (Ctrl+C) para desligamento gracioso. - **Desligamento:** Desliga os servidores gRPC e HTTP. **Como executar:** 1. **Instale as dependências:** ```bash go get github.com/envoyproxy/go-control-plane@v0.11.0 ``` 2. **Salve o código como `main.go`.** 3. **Execute o código:** ```bash go run main.go ``` **Pontos importantes:** * **Substitua o exemplo de recurso:** A parte mais importante é substituir o exemplo `test.MakeRoute` na função `generateSnapshot()` com a lógica para gerar seus próprios recursos (Clusters, Listeners, Routes, etc.) que você deseja servir através do MCP. * **ID do Nó:** Certifique-se de que o `nodeID` no `generateSnapshot()` corresponda ao ID do nó que está solicitando configurações. * **Callbacks:** Implemente seus próprios callbacks para lidar com eventos como conexões de clientes, solicitações de recursos e erros. * **Configuração:** Este é um exemplo mínimo. Você precisará adicionar lógica para carregar a configuração de um arquivo, banco de dados ou outra fonte. * **Versões:** Certifique-se de usar versões compatíveis do `go-control-plane` e `mcp-go`. O exemplo acima usa `go-control-plane@v0.11.0`. * **Segurança:** Este exemplo não inclui nenhuma segurança. Em um ambiente de produção, você precisará adicionar autenticação e autorização. Este exemplo fornece uma base sólida para construir um servidor MCP em Golang. Você precisará adaptá-lo às suas necessidades específicas.

mcp-scholar

"mcp\_scholar" é uma ferramenta baseada em Python para pesquisar e analisar artigos do Google Scholar, com suporte a recursos como buscas baseadas em palavras-chave e integração com clientes MCP e Cherry Studio. Ela oferece funcionalidades como buscar os artigos mais citados de perfis do Scholar e resumir as principais pesquisas.

LINE Bot MCP Server

Servidor MCP que integra a API de Mensagens do LINE para conectar um Agente de IA à Conta Oficial do LINE.

MCP Memory

A server that gives MCP clients (Cursor, Claude, Windsurf, etc.) the ability to remember user information across conversations using vector search technology.

MCP Airtable Server

Provides tools for AI assistants to interact with Airtable databases, enabling CRUD operations on Airtable bases and tables.

allabout-mcp

Servidores MCP e mais

Playwright MCP

A Model Context Protocol server that provides browser automation capabilities using Playwright, enabling LLMs to interact with web pages through structured accessibility snapshots without requiring screenshots or visually-tuned models.

Claude Debugs for You

Habilitar o Claude (ou qualquer outro LLM) a depurar seu código interativamente (definir pontos de interrupção e avaliar expressões no frame da pilha). É independente da linguagem, assumindo suporte ao console do depurador e um launch.json válido para depuração no VSCode.

Kubecost MCP Server

An implementation that enables AI assistants to interact with Kubecost cost management platform through natural language, providing access to budget management and cost analysis features.

Agentic Commerce MCP Demo

Enables interactive restaurant discovery and ordering through a synthetic commerce flow with rich HTML UI. Demonstrates agentic commerce UX with tools to find restaurants, view menus, place mock orders, and generate receipts.

Neva

SDK do servidor MCP para Rust

Remote MCP Server on Cloudflare

Um servidor para hospedar ferramentas do Protocolo de Contexto de Modelo (MCP) no Cloudflare Workers com autenticação OAuth, permitindo que o Claude AI e outros clientes MCP acessem capacidades estendidas.

mcp-bauplan

Um servidor MCP para interagir com dados e executar pipelines usando Bauplan.

Grasp

An open-source self-hosted browser agent that provides a dockerized browser environment for AI automation, allowing other AI apps and agents to perform human-like web browsing tasks through natural language instructions.

mcp-server-diceroll

fumievalさんのパクリ

Public MCP Server

A basic Model Context Protocol (MCP) server implementation that provides a foundation for MCP server development. The README doesn't specify particular functionality, suggesting it may be a template or starting point for building custom MCP servers.