FRITZ!Box MCP Server

Controle roteadores AVM FRITZ!Box - gerencie dispositivos, WiFi, configurações de rede, controles parentais e agende ações com atraso programado

GitHub
19
Experimente este MCPPatrocinado

Documentação

FRITZ!Box MCP Server

Controle seu roteador FRITZ!Box através de assistentes de IA como o Claude usando linguagem natural.

[Listed on mcpservers.org

Listado em mcpservers.org

](https://mcpservers.org/servers/kambriso/fritzbox-mcp-server)

Build Release Pipeline

SLSA Level 3

SLSA Nível 3

LicenseGo Version

Versão Go

Sumário

1. Introdução

1.1. O que é isto?

Este servidor MCP permite que você interaja com seu roteador FRITZ!Box usando assistentes de IA. Faça perguntas em linguagem natural, analise sua rede, gerencie dispositivos, solucione problemas e configure ajustes sem tocar na interface web.

1.2. Como funciona (Arquitetura de Segurança)

Architecture Diagram

O servidor MCP roda no seu computador e atua como uma ponte segura entre agentes de IA (que rodam na nuvem) e seu FRITZ!Box (que permanece completamente local).

Suas credenciais do FRITZ!Box são armazenadas localmente em um arquivo .env no seu computador. O servidor MCP usa essas credenciais para se comunicar com seu FRITZ!Box apenas pela sua rede local.

O agente de IA recebe apenas os resultados (como "3 dispositivos conectados" ou "Tempo de atividade do roteador: 5 dias"), nunca suas credenciais ou acesso direto ao seu roteador.

Recursos críticos de segurança:

  • Seu FRITZ!Box nunca precisa de exposição à internet
  • Nenhuma porta precisa ser aberta
  • Nenhuma conexão de nuvem ao seu roteador
  • As credenciais permanecem no seu computador
  • Toda a comunicação com o roteador acontece apenas na sua rede local

1.3. Por que usar isto?

Funciona com TODOS os modelos e versões de firmware do FRITZ!Box. Quando a AVM lança novos recursos ou modelos, este servidor se adapta automaticamente. Sem necessidade de atualizações.

Diferente de outras soluções que quebram com atualizações de firmware ou funcionam apenas com modelos específicos, este servidor descobre as capacidades do seu roteador em tempo real.

2. Guia do Usuário

2.1. Início Rápido

2.1.1. 1. Instalação

Baixe e instale com verificação automática de checksum:

curl -fsSL https://raw.githubusercontent.com/kambriso/fritzbox-mcp-server/main/install.sh | sh

O instalador irá:

  • Detectar sua plataforma (SO e arquitetura) automaticamente
  • Baixar a versão mais recente do GitHub
  • Verificar checksums SHA256 por segurança
  • Instalar em ~/.local/bin/fritz-mcp
  • Tornar o binário executável
DicaPersonalize a instalação: # Install specific version FRITZBOX_MCP_VERSION=<tag> curl -fsSL https://raw.githubusercontent.com/kambriso/fritzbox-mcp-server/main/install.sh | sh # Install to custom directory FRITZBOX_MCP_INSTALL_DIR=/usr/local/bin curl -fsSL https://raw.githubusercontent.com/kambriso/fritzbox-mcp-server/main/install.sh | sh
Instalação Manual (Todas as plataformas)

Obtenha o binário para seu sistema em Releases:

Linux

fritz-mcp-linux-amd64.tar.xz ou fritz-mcp-linux-arm64.tar.xz

macOS

fritz-mcp-darwin-amd64.tar.xz ou fritz-mcp-darwin-arm64.tar.xz

Windows

fritz-mcp-windows-amd64.zip ou fritz-mcp-windows-arm64.zip

Extraia o arquivo e torne-o executável (Linux/macOS):

tar -xJf fritz-mcp-linux-amd64.tar.xz
chmod +x fritz-mcp

Windows: Extraia o arquivo ZIP.

2.1.2. 2. Configuração Interativa

A maneira mais fácil de configurar seu FRITZ!Box é usando o modo de configuração interativa. Isso descobrirá automaticamente seu roteador na rede e o guiará pelo processo de configuração.

./fritz-mcp --setup

O modo de configuração irá:

  1. Descobrir: Encontrar dispositivos FRITZ!Box usando SSDP na sua rede local.
  2. Identificar: Detectar automaticamente o Mesh Master (gateway).
  3. Configurar: Solicitar seu host, nome de usuário, senha e preferência de TLS.
  4. Proteger: Salvar credenciais em um arquivo .env com permissões 0600 (leitura/escrita apenas por você).

2.1.3. 3. Permissões do Usuário FRITZ!Box

Seu usuário FRITZ!Box precisa de acesso total às configurações.

Na interface web do FRITZ!Box (http://fritz.box):

  1. Vá para Sistema → FRITZ!Box-Benutzer → [Seu Usuário] → Berechtigungen
  2. Ative: "FRITZ!Box-Einstellungen" (ou "O usuário pode visualizar e editar todas as configurações do FRITZ!Box")

2.1.4. 4. Configure seu cliente MCP

Para Windows e macOS, o Claude Desktop é a opção mais direta. A partir de 15 de junho de 2026, a Anthropic não fornece um aplicativo oficial do Claude Desktop para Linux. No Linux, use qualquer cliente compatível com MCP ou integração de editor que possa iniciar um servidor stdio local e adicione fritz-mcp lá com o mesmo comando mostrado abaixo.

Caminhos de configuração do Claude Desktop:

Windows

%APPDATA%\Claude\claude_desktop_config.json

macOS

~/Library/Application Support/Claude/claude_desktop_config.json

Adicione o servidor:

{
  "mcpServers": {
    "fritzbox": {
      "command": "/path/to/fritz-mcp"
    }
  }
}
DicaWindows: C:\\Users\\YourName\\path\\to\\fritz-mcp.exe (observe as barras invertidas duplas) macOS/Linux com instalação automatizada: ~/.local/bin/fritz-mcp macOS/Linux com instalação manual: Caminho absoluto para onde você colocou o binário, ex.: /Users/yourname/bin/fritz-mcp

Reinicie seu cliente MCP após alterações de configuração.

2.2. O que você pode fazer?

2.2.1. Fazer Perguntas

"Qual é o meu endereço IP externo?"

"Mostre-me todos os dispositivos conectados"

"Há quanto tempo o roteador está ligado?"

"Qual é a minha velocidade atual de internet?"

"Meu WiFi é seguro?"

2.2.2. Analisar Sua Rede

"Analise a saúde da minha rede e me diga se está tudo certo"

O Claude verificará a qualidade da sua conexão, identificará problemas, explicará padrões nos seus logs e fornecerá recomendações.

Exemplo de resposta:

Network Health Analysis

Connection: Healthy ✓
- Speed: 112 / 37 Mbit/s (down/up)
- Signal quality: Excellent
- No errors detected

Daily Reconnections at 04:00:
This is normal. Your ISP enforces 24-hour session limits.
FRITZ!Box reconnects proactively to avoid forced disconnection.

One DSL resync on Dec 7 at 12:52:
Single event, recovered in 4 minutes. Monitor for recurring
patterns, but not concerning as an isolated incident.

Overall: Network operating optimally.

2.2.3. Gerenciar Dispositivos

"Mostre todos os dispositivos WiFi"

"Quais dispositivos estão usando mais banda?"

"Liste dispositivos desconhecidos na minha rede"

"Priorize a banda do meu notebook - tenho uma videochamada"

2.2.4. Controle Parental e Agendamento

"Bloqueie o Nintendo Switch em 20 minutos"

"Desative a internet para todos os dispositivos de jogos durante o horário de trabalho"

"Ative o WiFi para convidados às 18h para a festa"

2.2.5. Solução de Problemas

"Por que minha internet está lenta?"

"Verifique se há problemas de conexão"

"Mostre-me desconexões recentes"

2.3. Exemplos

2.3.1. Verificação de Saúde da Rede

Prompt: "Analise a saúde da minha rede e verifique se tudo está funcionando de forma otimizada"

O Claude autonomamente:

  1. Consulta informações do dispositivo e tempo de atividade
  2. Verifica status e estabilidade da conexão
  3. Analisa qualidade da linha e taxas de erro
  4. Revisa logs em busca de padrões
  5. Distingue comportamento normal de problemas
  6. Fornece recomendações

2.3.2. Inventário de Dispositivos

Prompt: "Mostre-me todos os dispositivos - quais estão online e há dispositivos desconhecidos?"

O Claude:

  1. Lista todos os dispositivos registrados
  2. Categoriza por status (online/offline)
  3. Agrupa por tipo de conexão (WiFi/Ethernet)
  4. Identifica dispositivos desconhecidos ou suspeitos
  5. Fornece análise de segurança

2.3.3. Ações com Atraso de Tempo

Prompt: "Bloqueie o console de jogos em 20 minutos"

O Claude agenda a ação para executar automaticamente, mesmo após você fechar o chat.

Isso usa o modo CLI do servidor para execução persistente em segundo plano.

2.4. Solução de Problemas

2.4.1. Não é possível conectar ao FRITZ!Box

Verifique se seu roteador está acessível:

ping fritz.box

Verifique as credenciais no arquivo .env.

Garanta que seu usuário FRITZ!Box tenha a permissão de configurações completas ativada.

2.4.2. Seu cliente MCP não vê o servidor

Se você usa o Claude Desktop no Windows ou macOS, verifique se o caminho em claude_desktop_config.json é absoluto e correto.

No Linux, verifique se o comando/caminho na configuração do servidor do seu cliente MCP é absoluto e correto.

Usuários Windows: Use barras invertidas duplas nos caminhos.

Reinicie seu cliente MCP após alterações de configuração.

2.4.3. Erros de permissão

Seu usuário FRITZ!Box precisa da permissão "FRITZ!Box-Einstellungen" ativada. Veja a seção de configuração acima.

Toda a comunicação permanece na sua rede local. Suas credenciais são armazenadas localmente em um arquivo .env e usadas apenas para se comunicar com seu FRITZ!Box. A IA recebe apenas os resultados das operações, nunca suas credenciais.

Sem serviços de nuvem. Sem servidores externos. Tudo roda localmente.

2.5.2. Supply chain Levels for Software Artifacts (SLSA)

Este projeto fornece proveniência SLSA (Supply chain Levels for Software Artifacts) para todos os binários de lançamento. A proveniência SLSA atesta criptograficamente que os binários foram construídos a partir de código-fonte específico por um construtor confiável.

Duas provas independentes estão disponíveis:

  1. SHA256SUMS - Reprodutibilidade entre forges (mesma fonte produz binários idênticos no GitLab e GitHub)
  2. Proveniência SLSA - Atestado de cadeia de suprimentos (prova a origem do binário e o processo de construção)
GitLab (SLSA Nível 2)

Os lançamentos do GitLab incluem proveniência SLSA Nível 2 via artifacts-metadata.json.

Verificação:

# Download binary and SLSA metadata
glab release download <tag> -R kambriso/fritzbox-mcp-server \
  -n 'fritz-mcp-linux-amd64' -n 'artifacts-metadata.json' # (1)

# Examine provenance
cat artifacts-metadata.json | jq '.predicateType'
# Output: "https://slsa.dev/provenance/v1"

# Verify artifact digest matches
sha256sum fritz-mcp-linux-amd64
# Compare with digest in artifacts-metadata.json subjects
  1. A tag git a ser verificada, ex.: v0.7.7

Alternativamente, use o alvo do Makefile:

make verify-slsa-gitlab-linux-amd64 SLSA_TAG=<tag>

A proveniência inclui:

  • Formato de declaração in-toto (https://in-toto.io/Statement/v0.1)
  • Predicado SLSA v1 com definição de construção
  • Digests SHA256 para todos os artefatos
  • Parâmetros de ambiente CI do GitLab
GitHub (SLSA Nível 3)

Os lançamentos do GitHub incluem proveniência SLSA Nível 3 via slsa-github-generator.

Verificação usando slsa-verifier:

# Download binary and provenance
gh release download <tag> -R kambriso/fritzbox-mcp-server \
  -p 'fritz-mcp-linux-amd64' -p '*.intoto.jsonl'

# Verify provenance
go run github.com/slsa-framework/slsa-verifier/v2/cli/slsa-verifier@latest \
  verify-artifact fritz-mcp-linux-amd64 \
  --provenance-path multiple.intoto.jsonl \
  --source-uri github.com/kambriso/fritzbox-mcp-server \
  --source-tag <tag> # (1)
  1. A tag git a ser verificada, ex.: v0.7.7

Alternativamente, use o alvo do Makefile:

make verify-slsa-github-linux-amd64 SLSA_TAG=<tag>
Verificação de Assinatura Cosign

Todos os binários são assinados usando Cosign com assinatura sem chave (OIDC). Assinaturas e certificados estão incluídos nos artefatos de lançamento.

# Download binary, signature, and certificate
# (from GitLab artifacts or GitHub release)

# Verify signature
cosign verify-blob \
  --signature fritz-mcp-linux-amd64.sig \
  --certificate fritz-mcp-linux-amd64.pem \
  --certificate-oidc-issuer https://gitlab.com \
  fritz-mcp-linux-amd64
Verificação Independente

Toda a verificação pode ser realizada offline usando ferramentas padrão:

# 1. Verify checksums match across forges
diff <(curl -sL gitlab-SHA256SUMS) <(curl -sL github-SHA256SUMS)

# 2. Verify binary matches checksum
sha256sum -c SHA256SUMS

# 3. Verify SLSA provenance (slsa-verifier or manual inspection)
# 4. Verify cosign signature (requires network for certificate chain)

# Full trust chain: source code -> CI build -> signed artifact -> your machine

2.5.3. Verificação Cruzada entre Forges Git

Este projeto publica lançamentos idênticos no GitLab e no GitHub. A verificação cruzada entre forges prova que nenhuma das forges foi comprometida - se um atacante modificasse binários em uma das forges, os checksums não corresponderiam.

Isso é independente do SLSA: enquanto o SLSA prova "este binário veio desta fonte", a verificação cruzada entre forges prova "ambas as forges servem o mesmo binário".

# Download checksums from both forges
curl -sL "https://gitlab.com/.../SHA256SUMS" -o gitlab-SHA256SUMS
curl -sL "https://github.com/.../SHA256SUMS" -o github-SHA256SUMS

# Compare - must be identical
diff gitlab-SHA256SUMS github-SHA256SUMS && echo "Cross-forge verification passed"

# Or using CLI tools:
gh release download <tag> -R kambriso/fritzbox-mcp-server -p 'SHA256SUMS' -D github
glab release download <tag> -R kambriso/fritzbox-mcp-server -n 'SHA256SUMS' -D gitlab
diff github/SHA256SUMS gitlab/SHA256SUMS

Por que isso importa:

  • Protege contra comprometimento de uma única forge
  • Valida que builds reproduzíveis funcionam corretamente
  • Não requer confiança em nenhuma plataforma única
  • Usuários podem verificar com ferramentas padrão (curl, diff, sha256sum)

2.6. Considerações sobre Uso de Tokens

Este servidor MCP expõe 143 ferramentas ao assistente de IA. Cada definição de ferramenta (nome, descrição, esquema JSON) é enviada com cada mensagem.

2.6.1. Impacto no Claude Code / API Claude

  • Sobrecarga de tokens: ~25.000-30.000 tokens por mensagem apenas para definições de ferramentas
  • Estimativa de custo: ~$0,08/mensagem (Sonnet) ou ~$0,45/mensagem (Opus) em sobrecarga de ferramentas
  • Uso de contexto: Esquemas de ferramentas consomem espaço da janela de contexto que poderia ser usado para conversa

2.6.2. Recomendações

Para uso ocasional

Desative o servidor quando não for necessário:

# In Claude Code, disable the MCP server:
claude --mcp-server fritzbox=off

# Or remove from mcpServers in ~/.claude.json
Para uso frequente

Considere ativar apenas para projetos específicos que precisam de acesso ao roteador, em vez de globalmente.

Para LLMs locais

Se estiver usando com modelos locais (llama.cpp, Ollama), 143 ferramentas podem sobrecarregar modelos menores. Use filtragem de ferramentas para expor apenas as necessárias.

DicaApós a primeira mensagem em uma sessão, o cache de prompt do Claude reduz o custo de tokens para mensagens subsequentes. A sobrecarga é mais significativa para conversas curtas.

3. Guia do Desenvolvedor

3.1. Arquitetura

Este servidor é orientado por runtime e agnóstico de modelo:

  • Sem estruturas de serviço codificadas
  • Descobre capacidades dinamicamente a partir dos descritores de serviço do seu FRITZ!Box
  • Funciona com atualizações de firmware automaticamente
  • Suporta todos os modelos FRITZ!Box (testado com 7490, 7590)

3.2. Escolha do SDK MCP

Este projeto usa o SDK MCP da comunidade (mark3labs/mcp-go v0.7.0) em vez do SDK oficial (modelcontextprotocol/go-sdk) devido a problemas de compatibilidade:

  • Problemas do SDK oficial: Ferramentas não aparecem nos clientes MCP apesar do registro adequado
    • Issue #395: Condições de corrida na inicialização e timeouts do cliente
    • Issue #200: Problemas de geração de esquema com tipos ponteiro (corrigido no PR #338)
  • SDK da comunidade: Testado em batalha, sem problemas de compatibilidade conhecidos
  • Incompatibilidade de API: Os dois SDKs não são compatíveis em API (veja documento de design do SDK oficial)

O SDK oficial usa uma implementação JSON-RPC diferente e interface de transporte de nível mais baixo. Embora ambos os SDKs funcionem de forma independente, o SDK da comunidade provou ser mais confiável para transporte stdio com clientes Claude Code.

3.3. Configuração de Desenvolvimento

3.3.1. Pré-requisitos

  • Go 1.25 ou posterior
  • Um roteador FRITZ!Box na sua rede local para testes
  • Nome de usuário e senha do FRITZ!Box

3.3.2. Clonar e Compilar

git clone git@github.com:kambriso/fritz-mcp.git
cd fritz-mcp
make help  # See available build targets

3.3.3. Configuração

Crie o arquivo .env com suas credenciais do FRITZ!Box:

cp .env.example .env
# Edit with your credentials
editor .env

Variáveis necessárias:

FRITZ_HOST=fritz.box          # FRITZ!Box hostname or IP
FRITZ_PORT=49000              # Service port (default: 49000)
FRITZ_USERNAME=your-username  # FRITZ!Box username
FRITZ_PASSWORD=your-password  # FRITZ!Box password

3.3.4. Permissões do Usuário FRITZ!Box

A conta de usuário deve ter a permissão FRITZ!Box-Einstellungen habilitada:

  • Alemão: "Der Benutzer kann alle Einstellungen der FRITZ!Box sehen und bearbeiten"
  • Inglês: "The user can view and edit all FRITZ!Box settings"

Configure na interface web do FRITZ!Box:

System → FRITZ!Box-Benutzer → [Your User] → Berechtigungen

Marque a caixa de seleção para "FRITZ!Box-Einstellungen".

3.4. Compilação

3.4.1. Build de Desenvolvimento

make build
./fritz-mcp

3.4.2. Builds de Produção

Compile para todas as plataformas suportadas:

make dists

Isso cria binários em dist/ para: * Linux (amd64, arm64, 386, arm) * macOS (amd64, arm64) * Windows (amd64, arm64) * WASI (wasm) - WebAssembly com funcionalidade limitada

3.4.3. Notas sobre o Build WASI

Um build WASI (WebAssembly System Interface) está incluído para demonstrar a portabilidade do código. No entanto, o alvo wasip1 do Go tem limitações significativas para aplicações de rede:

  • Sem acesso à rede - Go só suporta WASI Preview 1, que não possui APIs de socket
  • Acesso restrito ao sistema de arquivos
  • Fornece sandbox de segurança baseado em capacidades
NotaEmbora WasmEdge suporte sockets e WASI Preview 2 inclua wasi-sockets, o Go atualmente só tem como alvo wasip1 (selado sem rede). WASI Preview 2 foi lançado em janeiro de 2024, mas o Go não tem cronograma anunciado para suporte a GOOS=wasip2 (acompanhado em Issue #65333). Go 1.24 (fev 2025) e Go 1.25 (ago 2025) não incluem wasip2.

Recomendação: Use binários nativos ou contêineres multi-arquitetura para produção. O build WASI demonstra a portabilidade do WebAssembly, mas não pode funcionar como um serviço de rede com as versões atuais do Go.

Compile para uma plataforma específica:

GOOS=linux GOARCH=amd64 make dist
GOOS=darwin GOARCH=arm64 make dist
GOOS=windows GOARCH=amd64 make dist

3.4.4. Builds Reproduzíveis

Todos os binários de lançamento são reproduzíveis: compilar a partir do mesmo código-fonte produz binários idênticos byte a byte. Isso permite verificação independente de que os binários publicados correspondem ao código-fonte.

Por que a Reproduzibilidade é Importante

Builds reproduzíveis permitem:

  • Verificação independente dos artefatos de lançamento
  • Detecção de adulteração na cadeia de suprimentos
  • Confiança de que os binários correspondem ao código-fonte revisado
  • Base para atestados SLSA
Flags de Build para Reproduzibilidade

O Makefile usa estas flags para garantir builds determinísticos:

-trimpath                    # Remove absolute paths
-buildvcs=false              # Disable VCS info embedding
-buildid=                    # Clear build ID
SOURCE_DATE_EPOCH=$(git)     # Use commit timestamp
Requisitos da Cadeia de Ferramentas

O Go produz binários reproduzíveis ao usar a mesma distribuição da cadeia de ferramentas. No entanto, diferentes distribuições do Go (upstream vs. pacotes Fedora/Debian) podem produzir binários diferentes devido a patches ou experimentos de build específicos da distribuição.

Diferenças conhecidas:

  • Fedora Go 1.25.6 inclui GOEXPERIMENT=nodwarf5 compilado na cadeia de ferramentas
  • Upstream Go 1.25.6 (de go.dev ou contêiner golang:1.25) não tem experimentos
  • Essas diferenças estão embutidas na seção .go.buildinfo
Verificando Builds Locais

Para reproduzir builds do GitLab CI localmente, use o mesmo contêiner golang:1.25:

# Build all platforms in container (matches CI environment)
make dists-container

# Compare with published release checksums
sha256sum -c SHA256SUMS

A imagem Docker golang:1.25 corresponde à distribuição upstream do Go, garantindo reprodutibilidade entre ambientes.

Reproducibilidade em CI/CD

Tanto o GitLab CI quanto o GitHub Actions usam a cadeia de ferramentas oficial do Go 1.25: GitLab via imagem de contêiner golang:1.25, GitHub via actions/setup-go que baixa de go.dev. Ambos produzem binários idênticos byte a byte. Builds locais usando pacotes Go fornecidos pela distribuição (Fedora, Ubuntu, etc.) podem produzir binários diferentes devido a patches específicos da distribuição.

Para builds locais reproduzíveis byte a byte, use make dists-container que compila no contêiner golang:1.25.

3.5. Testes

3.5.1. Testes Unitários

go test -v ./...

3.5.2. Testes Automatizados e Benchmarks

O projeto inclui uma suíte de testes abrangente e um benchmark de desempenho.

# Run all tests
go test -v ./...

# Run the discovery benchmark
go test -v -bench=. .

3.6. Fluxo de Desenvolvimento

  1. Faça alterações no código-fonte
  2. Execute os testes: go test -v ./…​
  3. Compile: make build
  4. Teste localmente com seu FRITZ!Box
  5. Compile os binários distribuíveis: make dist

3.7. Processo de Lançamento

Os lançamentos são publicados automaticamente no repositório público quando uma tag de versão é enviada.

3.7.1. Configuração

O segredo PUBLIC_REPO_TOKEN está configurado e pronto para lançamentos.

3.7.2. Criando um Lançamento

# Ensure all tests pass
make check

# Tag the release (use semantic versioning)
git tag v1.0.0

# Push the tag to trigger the release workflow
git push origin v1.0.0

Os fluxos de trabalho do GitHub Actions irão:

Fluxo de trabalho de lançamento (release.yml)

  1. Compilar binários para todas as plataformas (Linux, macOS, Windows, WASI)
  2. Gerar somas de verificação SHA256
  3. Criar um lançamento em https://github.com/kambriso/fritzbox-mcp-server
  4. Enviar todos os binários e somas de verificação

Fluxo de trabalho de contêiner (container.yml)

  1. Compilar imagem de contêiner WASI (marcada com sufixo -wasi)
  2. Compilar contêiner multi-arquitetura (linux/amd64, linux/arm64)
  3. Publicar em ghcr.io/kambriso/fritzbox-mcp-server
NotaUse o contêiner multi-arquitetura para produção. O contêiner WASI demonstra portabilidade, mas o alvo wasip1 do Go não tem suporte a rede (aguardando suporte wasip2 em versões futuras do Go).

3.7.3. Plataformas de Lançamento Suportadas

Binários

  • Linux: amd64, arm64, 386, arm
  • macOS: amd64 (Intel), arm64 (Apple Silicon)
  • Windows: amd64, arm64
  • WASI: wasm (Go wasip1 - sem suporte a rede até wasip2)

Imagens de Contêiner

4. Suporte

Problemas

https://github.com/kambriso/fritzbox-mcp-server/issues

Código-Fonte

https://github.com/kambriso/fritz-mcp (privado)

5. Licença

Código-fonte disponível. Gratuito para exatamente um par de credenciais FRITZ!Box. Qualquer outra coisa requer uma licença comercial.

6. Contribuição

Contribuições são bem-vindas. Ao enviar um pull request, você concorda com o Contrato de Licença de Contribuidor.

CuidadoEste software é fornecido como está. Proteja seu FRITZ!Box com uma senha forte e garanta que ele não esteja exposto à internet.

FRITZ!Box é uma marca registrada da FRITZ! GmbH (anteriormente AVM GmbH). Este projeto não é afiliado, endossado ou patrocinado pela FRITZ! GmbH.