Projeto Hive
No description available
Ask AI about Projeto Hive
Powered by Claude Β· Grounded in docs
I know everything about Projeto Hive. Ask me about installation, configuration, usage, or troubleshooting.
0/500
Reviews
Documentation
OpenHive AI
Plataforma open-source de criacao e gestao de conteudo para redes sociais com IA.
Crie posts com imagens e legendas geradas por IA, agende publicacoes, extraia clips de videos do YouTube, gerencie tarefas, projetos e funis de vendas. Integra com Instagram, Telegram, Claude e Gemini (via MCP).
Tutorial em video
Clique na imagem acima para assistir o tutorial completo no YouTube.
O que o OpenHive faz
- Posts com IA - Gera imagens (Google Gemini) e legendas, publica no Instagram
- Editor Visual - Editor tipo Figma para slides: edite titulo, subtitulo, fonte, posicao, overlay, fundo, cantos, logo, indicadores, glass effect, word highlights e mais. Preview ao vivo em 1080px
- IA no Editor - Gere conteudo de slides com Gemini, refine textos com instrucoes em linguagem natural ("deixe mais curto", "mude o tom"), gere imagens de fundo por prompt
- Carrossel - Crie carrosseis com 2-10 slides (HTML/Tailwind renderizado ou IA)
- Carrossel Misto - Capa gerada por IA + slides em HTML/Template (melhor dos dois mundos)
- Carrossel Composto - Cada slide com fundo IA + overlay HTML/Tailwind com CSS variables do brand
- Brands - Cadastre marcas com logo, 6 cores, 3 fontes, tom de voz, produtos, site e Instagram. Agentes de IA podem pesquisar essas URLs para manter consistencia
- Design Systems - Biblioteca com 58 inspiracoes visuais (Stripe, Linear, Apple, Notion, Tesla, etc) para criar brands
- Calendario - Visualize e agende posts em calendario
- Tarefas - Gerencie gravacoes e publicacoes com prioridades e prazos
- Projetos - Organize conteudo em projetos com modulos
- Funis de Vendas - Construtor visual com drag and drop (React Flow)
- YouTube Clips - Extraia melhores momentos, crie clips verticais com face cam e legendas
- Telegram Bot - Crie e gerencie posts direto pelo Telegram
- MCP Server - 40 tools pra usar com Claude, Gemini Antigravity, Cursor e outros
- Equipe - Convide membros com permissoes por pagina
- Multi-Instagram - Conecte varias contas do Instagram
- Tema escuro - Interface dark mode com tons neutros (estilo Figma/Framer)
Arquitetura
βββββββββββββββββββββββββββββββββββββββββββββββββββ
β Clientes β
β Web (3000) β Telegram Bot β MCP (3002) β
ββββββββ¬ββββββββ΄ββββββββ¬βββββββββ΄βββββββ¬βββββββββββ
β β β
βΌ βΌ βΌ
βββββββββββββββββββββββββββββββββββββββββββββββββββ
β API Express (3001) β
β Auth β Posts β Tasks β Projects β Funnels β
β Generate β Upload β Instagram β Video Clips β
ββββ¬βββββββ¬βββββββ¬βββββββ¬βββββββ¬βββββββββββββββββββ
β β β β β
βΌ βΌ βΌ βΌ βΌ
Postgres Redis MinIO Gemini Renderer (3003)
(5432) (6379) (9000) API Puppeteer+Chromium
Packages
| Package | Descricao | Porta |
|---|---|---|
packages/api | API REST (Express + Prisma + BullMQ) | 3001 |
packages/web | Frontend (Next.js 14 + Tailwind) | 3000 |
packages/bot | Telegram Bot (grammy.js) | - |
packages/mcp | MCP Server HTTP (40 tools) | 3002 |
packages/mcp-cli | MCP CLI para IDEs externas (npm) | - |
packages/shared | Tipos TypeScript compartilhados | - |
scripts/renderer | HTML para PNG (Puppeteer) | 3003 |
scripts/video | Video Worker (Python + ffmpeg) | - |
Portas
| Porta | Servico | Uso |
|---|---|---|
| 3000 | Web (Next.js) | Dashboard |
| 3001 | API (Express) | REST API |
| 3002 | MCP Server | Model Context Protocol |
| 3003 | Renderer | HTML para PNG |
| 5432 | PostgreSQL | Banco de dados (interno Docker) |
| 5433 | PostgreSQL | Banco de dados (dev local, evita conflito) |
| 6379 | Redis | Filas BullMQ |
| 9000 | MinIO API | Storage S3 |
| 9001 | MinIO Console | UI do MinIO |
Como instalar
O OpenHive usa Docker Compose em todos os cenarios. Escolha a opcao que se encaixa no seu caso:
| Cenario | O que acontece | Arquivo |
|---|---|---|
| Desenvolvimento local | Docker Compose sobe o banco, cache e storage. A aplicacao roda com npm run dev. | docker-compose.yml |
| VPS com SSH | Docker Compose sobe tudo (infra + app) com um unico comando. | docker-compose.production.yml |
| Coolify | Voce aponta o repo e o Coolify usa o Docker Compose pra buildar e rodar tudo. | docker-compose.prod.yml |
| Easypanel | Voce aponta o repo e o Easypanel usa o Docker Compose pra buildar e rodar tudo. | docker-compose.prod.yml |
Resumo: em todos os casos voce precisa de Docker. A unica diferenca e se voce roda
docker composedireto no terminal ou se uma plataforma (Coolify/Easypanel) faz isso por voce.
Instalacao Local (Desenvolvimento)
Pre-requisitos
- Docker Desktop (ja inclui Docker Compose)
- Node.js 22 LTS (recomendado via fnm ou nvm)
- Git
Por que Docker? O Docker Compose sobe automaticamente o banco de dados (PostgreSQL), cache (Redis) e storage de imagens (MinIO). Voce nao precisa instalar nenhum desses manualmente.
Passo a passo
1. Clone o repositorio
git clone https://github.com/NetoNetoArreche/instapost.git
cd instapost
2. Configure o ambiente
cp .env.example .env
Abra o .env e substitua os valores CHANGE_ME por senhas seguras (ou use o setup automatico no passo abaixo).
3. Suba a infraestrutura com Docker Compose
docker compose up -d
Isso inicia 3 containers:
| Container | Servico | Porta |
|---|---|---|
instapost-postgres | PostgreSQL 16 | 5433 (mapeada de 5432 interna) |
instapost-redis | Redis 7 | 6379 |
instapost-minio | MinIO (S3) | 9000 (API) / 9001 (Console) |
Verifique se estao rodando:
docker compose ps
Os 3 devem aparecer como running (healthy).
4. Instale dependencias e rode migrations
npm install
npx prisma migrate deploy --schema=packages/api/prisma/schema.prisma
5. Inicie a aplicacao
npm run dev
Acesse:
- Web: http://localhost:3000
- API: http://localhost:3001
- MCP: http://localhost:3002/mcp
- MinIO Console: http://localhost:9001
6. Crie sua conta
Abra http://localhost:3000, clique em Registrar e crie sua conta. O primeiro usuario criado sera o Owner.
Setup automatico (alternativa)
Se preferir, o script setup.sh faz tudo de uma vez (gera .env com secrets aleatorios, sobe Docker, instala deps, roda migrations e cria usuario admin):
bash setup.sh
Login padrao: admin@instapost.local / admin123 (troque depois!)
Comandos uteis do Docker Compose
# Ver status dos containers
docker compose ps
# Ver logs de um servico especifico
docker compose logs postgres
docker compose logs redis
docker compose logs minio
# Parar tudo (dados persistem nos volumes)
docker compose down
# Parar e apagar todos os dados (recomecar do zero)
docker compose down -v
# Reiniciar um servico
docker compose restart postgres
Renderer Service (para carrosseis HTML)
O renderer e necessario para a funcionalidade de carrossel com HTML/CSS/Tailwind. Em dev local, rode separado:
docker compose -f docker-compose.production.yml up renderer -d
Instalacao via Docker Compose (VPS com SSH)
Para VPS com acesso SSH direto (sem Coolify/Easypanel). O Docker Compose sobe tudo β infra e aplicacao β em containers.
Pre-requisitos
- VPS Ubuntu 22+ (minimo 2GB RAM)
- Docker e Docker Compose instalados (como instalar Docker no Ubuntu)
- Git
O que o Docker Compose cria
O arquivo docker-compose.production.yml sobe 8 containers:
| Container | Servico | Porta exposta |
|---|---|---|
instapost-postgres | PostgreSQL 16 (banco de dados) | interna (5432) |
instapost-redis | Redis 7 (filas e cache) | interna (6379) |
instapost-minio | MinIO (storage S3 para imagens) | 9000 / 9001 |
instapost-api | API Express (backend) | 3001 |
instapost-web | Next.js (frontend) | 3000 |
instapost-bot | Telegram Bot | - |
instapost-mcp | MCP Server (40 tools) | 3002 |
renderer | Puppeteer (HTML para PNG) | 3003 |
Passo a passo
1. Clone e rode o setup
git clone https://github.com/NetoNetoArreche/instapost.git
cd instapost
bash setup.sh --production
O setup.sh --production:
- Gera o
.envcom secrets aleatorios - Roda
docker compose -f docker-compose.production.yml up -d(builda e sobe tudo) - Executa migrations do banco dentro do container da API
- Cria o usuario admin
2. Verifique se esta tudo rodando
docker compose -f docker-compose.production.yml ps
Todos os containers devem aparecer como running.
3. Acesse
- Web:
http://SEU_IP:3000 - API:
http://SEU_IP:3001 - MCP:
http://SEU_IP:3002/mcp - MinIO Console:
http://SEU_IP:9001
Login padrao: admin@instapost.local / admin123 (troque depois!)
Comandos uteis (producao)
# Ver status
docker compose -f docker-compose.production.yml ps
# Ver logs de um servico
docker compose -f docker-compose.production.yml logs api
docker compose -f docker-compose.production.yml logs web
# Reiniciar tudo
docker compose -f docker-compose.production.yml restart
# Atualizar para nova versao
git pull
docker compose -f docker-compose.production.yml up -d --build
# Parar tudo (dados persistem)
docker compose -f docker-compose.production.yml down
Configurar dominio com proxy reverso
Use Nginx ou Caddy na frente dos containers:
# /etc/nginx/sites-available/openhive
server {
server_name app.seudominio.com;
location / { proxy_pass http://127.0.0.1:3000; }
}
server {
server_name api.seudominio.com;
location / { proxy_pass http://127.0.0.1:3001; }
}
server {
server_name mcp.seudominio.com;
location / { proxy_pass http://127.0.0.1:3002; }
}
server {
server_name s3.seudominio.com;
location / { proxy_pass http://127.0.0.1:9000; }
}
Apos configurar o dominio, atualize no .env e reinicie:
# Edite o .env
FRONTEND_URL=https://app.seudominio.com
MINIO_PUBLIC_URL=https://s3.seudominio.com
# Reinicie para aplicar
docker compose -f docker-compose.production.yml up -d
Instalacao no Coolify
O Coolify e uma plataforma self-hosted que gerencia Docker Compose por voce. Ele le o arquivo docker-compose.prod.yml do repositorio, builda as imagens e sobe todos os containers automaticamente.
Pre-requisitos
- VPS Ubuntu 22+ (minimo 2GB RAM)
- Coolify instalado (como instalar)
O que o Coolify faz por voce
Ao apontar o Coolify para este repositorio, ele usa o docker-compose.prod.yml que sobe:
| Servico no Compose | O que e | Porta |
|---|---|---|
postgres | PostgreSQL 16 | interna |
redis | Redis 7 (com senha) | interna |
minio | MinIO (storage S3) | 9000 / 9001 |
api | API Express (backend) | 3001 |
web | Next.js (frontend) | 3000 |
telegram-bot | Telegram Bot | - |
mcp-server | MCP Server (40 tools) | 3002 |
renderer | Puppeteer (HTML para PNG) | 3003 |
O Coolify cuida de: build das imagens, SSL automatico, dominios, restart e logs.
Passo 1: Criar o projeto
- Acesse o painel do Coolify (ex:
http://sua-vps:8000) - Projects > Add New Project > nomeie "OpenHive"
Passo 2: Adicionar como Docker Compose
- Dentro do projeto, clique + New > Resource
- Selecione Docker Compose
- Em Git Repository > Public Repository
- URL:
https://github.com/NetoNetoArreche/instapost.git - Branch:
main - Docker Compose Location:
/docker-compose.prod.yml - Base Directory:
/ - Clique Save
Importante: o Coolify vai ler o
docker-compose.prod.ymle criar todos os servicos automaticamente. Voce nao precisa criar containers manualmente.
Passo 3: Configurar variaveis de ambiente
Va em Environment Variables. Apague tudo e cole apenas isto (trocando cada CHANGE_ME por uma senha inventada por voce):
DB_PASSWORD=CHANGE_ME
REDIS_PASSWORD=CHANGE_ME
MINIO_SECRET_KEY=CHANGE_ME
JWT_SECRET=CHANGE_ME
INTERNAL_SERVICE_TOKEN=CHANGE_ME
So essas 5 senhas. Nao precisa colocar Gemini, Instagram, Telegram, dominios nem nada mais aqui. Tudo isso voce configura depois pela interface web do OpenHive.
Passo 4: Primeiro deploy
- Clique Deploy
- Aguarde ~10 minutos (build das imagens)
- Quando aparecer Running (healthy), esta pronto
Passo 5: Configurar dominios
Agora que esta rodando, voce precisa dizer ao Coolify quais servicos devem ser acessiveis. Voce NAO precisa ter um dominio proprio β o Coolify gera URLs automaticas.
Va em Configuration > General. Para cada servico abaixo, clique Generate Domain (ou coloque seu dominio se tiver um):
| Servico | Porta | O que e |
|---|---|---|
| web | 3000 | Dashboard β o que voce acessa no navegador |
| api | 3001 | Backend β a web precisa dele pra funcionar |
| minio | 9000 | Storage β onde as imagens ficam salvas |
| mcp-server | 3002 | MCP β conexao com IDEs (opcional) |
O Coolify gera URLs automaticas tipo openhive-web-abc123.coolify.io. Se voce tiver dominio proprio pode usar, mas nao e obrigatorio.
O Coolify gera SSL (HTTPS) automaticamente.
Anote as URLs geradas β voce vai precisar de 2 delas no proximo passo.
Passo 6: Atualizar as URLs no ambiente
Volte em Environment Variables e adicione estas 2 linhas, usando as URLs que o Coolify gerou:
FRONTEND_URL=https://url-do-web-que-o-coolify-gerou
MINIO_PUBLIC_URL=https://url-do-minio-que-o-coolify-gerou
Clique Save e depois Deploy novamente para aplicar.
Passo 7: Acessar e configurar
- Abra a URL do web no navegador (a mesma que voce colocou no FRONTEND_URL)
- Clique Registrar e crie sua conta (primeiro usuario = Owner)
- Va em Configuracoes no menu lateral e configure tudo pela interface:
- Geracao de Imagens β cole sua chave do Google Gemini (pegue aqui)
- Instagram β conecte sua conta (opcional)
- Telegram Bot β cole o token do BotFather (opcional)
Resumo: voce NAO precisa comprar um dominio. O Coolify gera URLs automaticas. Todas as integracoes (Gemini, Instagram, Telegram) sao configuradas pela interface web, nao por variaveis de ambiente.
Instalacao no Easypanel
O Easypanel e um painel de controle self-hosted para Docker. Ele suporta deploy via Docker Compose β o jeito mais facil de subir o OpenHive inteiro com poucos cliques.
Pre-requisitos
- VPS Ubuntu 22+ (minimo 2GB RAM)
- Easypanel instalado (como instalar)
O que vai ser criado
O Docker Compose (docker-compose.prod.yml) sobe 8 containers automaticamente:
| Container | Servico | Porta |
|---|---|---|
postgres | PostgreSQL 16 (banco de dados) | interna |
redis | Redis 7 (filas e cache) | interna |
minio | MinIO (storage S3 para imagens) | 9000 / 9001 |
api | API Express (backend) | 3001 |
web | Next.js (frontend) | 3000 |
telegram-bot | Telegram Bot | - |
mcp-server | MCP Server (40 tools) | 3002 |
renderer | Puppeteer (HTML para PNG) | 3003 |
Voce nao precisa criar cada servico manualmente β o Docker Compose faz tudo.
Passo 1: Criar o projeto
- Acesse o painel do Easypanel (ex:
http://sua-vps:3000) - Clique Create Project > nome:
openhive
Passo 2: Adicionar como Docker Compose
- Dentro do projeto, clique + Service
- Selecione Docker Compose
- Em Source, selecione Github (ou Git URL para repo publico)
- URL:
https://github.com/NetoNetoArreche/instapost.git - Branch:
main - Docker Compose Path:
docker-compose.prod.yml - Clique Save
O Easypanel vai ler o
docker-compose.prod.ymle criar todos os 8 servicos automaticamente. Voce nao precisa configurar containers manualmente.
Passo 3: Configurar variaveis de ambiente
Clique em Ambiente no menu lateral. Apague tudo que o Easypanel colocou la (ele preenche automaticamente com valores de exemplo, ignore tudo). Cole apenas isto:
DB_PASSWORD=MinhaSenh4Forte1
REDIS_PASSWORD=MinhaSenh4Forte2
MINIO_SECRET_KEY=MinhaSenh4Forte3
JWT_SECRET=MinhaSenh4Forte4
INTERNAL_SERVICE_TOKEN=MinhaSenh4Forte5
Troque as senhas de exemplo acima por senhas suas. Pode inventar qualquer coisa, so nao use @, # ou espacos.
So essas 5 senhas e mais nada.
NAO COLOQUE nenhuma destas variaveis agora (elas vem DEPOIS):
FRONTEND_URLβ voce adiciona no Passo 6, depois que o Easypanel gerar a URLMINIO_PUBLIC_URLβ voce adiciona no Passo 6, depois que o Easypanel gerar a URLNANO_BANANA_API_KEYβ voce configura pela interface web do OpenHive (menu Configuracoes), nao aquiNANO_BANANA_PROVIDERβ mesmo, pela interface webTELEGRAM_BOT_TOKENβ mesmo, pela interface webINSTAGRAM_ACCESS_TOKENβ mesmo, pela interface webDATABASE_URLβ o Docker Compose monta sozinho usando DB_PASSWORDREDIS_URLβ o Docker Compose monta sozinho usando REDIS_PASSWORDMINIO_ENDPOINTβ o Docker Compose configura sozinho
Como as senhas funcionam? Voce inventa uma senha para
DB_PASSWORDe o Docker Compose automaticamente usa essa mesma senha para criar o banco Postgres E para a API conectar nele. Voce nao precisa saber a connection string nem configurar nada separado β o Compose monta tudo sozinho internamente. O mesmo vale paraREDIS_PASSWORDeMINIO_SECRET_KEY.
Clique Salvar.
Passo 4: Primeiro deploy
- Clique em Implantar (botao verde no topo)
- Aguarde ~10 minutos (ele vai buildar as imagens Docker β e normal demorar)
- Quando os servicos aparecerem como Running, esta pronto
O app ja funciona neste ponto, so as imagens nao vao carregar ate voce configurar os dominios nos proximos passos.
Passo 5: Descobrir o IP da sua VPS
Voce precisa do IP da sua VPS para criar os dominios. No Easypanel, o IP aparece no canto inferior esquerdo do painel (na barra lateral, embaixo de tudo). E algo como 123.45.67.89.
Anote esse IP β voce vai usar no proximo passo.
Passo 6: Configurar dominios
Voce precisa criar 4 dominios para os servicos ficarem acessiveis pelo navegador. Voce NAO precisa comprar um dominio β vamos usar o sslip.io que e gratuito e resolve automaticamente pro IP da sua VPS.
- Clique em Dominios no menu lateral esquerdo
- Clique em Adicionar Dominio. Vai abrir um formulario com os campos: Host, Porta, Servico Compose, etc.
- Crie os 4 dominios abaixo, um de cada vez:
Dominio 1 β Web (Dashboard):
- Host:
web.SEU_IP.sslip.io(ex:web.123.45.67.89.sslip.io) - Porta:
3000 - Servico Compose:
web - Caminho:
/ - Clique Criar
Dominio 2 β API (Backend):
- Host:
api.SEU_IP.sslip.io(ex:api.123.45.67.89.sslip.io) - Porta:
3001 - Servico Compose:
api - Caminho:
/ - Clique Criar
Dominio 3 β MinIO (Storage de imagens):
- Host:
minio.SEU_IP.sslip.io(ex:minio.123.45.67.89.sslip.io) - Porta:
9000 - Servico Compose:
minio - Caminho:
/ - Clique Criar
Dominio 4 β MCP Server (para IDEs, opcional):
- Host:
mcp.SEU_IP.sslip.io(ex:mcp.123.45.67.89.sslip.io) - Porta:
3002 - Servico Compose:
mcp-server - Caminho:
/ - Clique Criar
O que e sslip.io? E um servico DNS gratuito. Quando voce acessa
web.123.45.67.89.sslip.io, ele automaticamente resolve para o IP123.45.67.89. Nao precisa configurar nada nem comprar dominio. Se voce tiver um dominio proprio, pode usar ele no lugar (ex:app.seusite.com).
Passo 7: Atualizar as URLs no ambiente
- Clique em Ambiente no menu lateral
- Adicione estas 2 linhas no final das variaveis que ja estao la, trocando
SEU_IPpelo IP real da sua VPS:
FRONTEND_URL=https://web.SEU_IP.sslip.io
MINIO_PUBLIC_URL=https://minio.SEU_IP.sslip.io
Exemplo real (se seu IP e 123.45.67.89):
FRONTEND_URL=https://web.123.45.67.89.sslip.io
MINIO_PUBLIC_URL=https://minio.123.45.67.89.sslip.io
- Clique Salvar
- Clique Implantar (botao verde no topo) para aplicar as mudancas
Passo 8: Acessar e configurar
- Abra
https://web.SEU_IP.sslip.iono navegador (troqueSEU_IPpelo IP real) - Clique Registrar e crie sua conta (primeiro usuario vira Owner automaticamente)
- Va em Configuracoes no menu lateral e configure tudo pela interface web:
- Geracao de Imagens β cole sua chave do Google Gemini (pegue aqui)
- Instagram β conecte sua conta (opcional)
- Telegram Bot β cole o token do BotFather (opcional)
Resumo: voce NAO precisa comprar um dominio. O sslip.io gera URLs automaticas a partir do IP da sua VPS. Todas as integracoes (Gemini, Instagram, Telegram) sao configuradas pela interface web do OpenHive, nao por variaveis de ambiente.
Alternativa: criar servicos manualmente
Se preferir nao usar Docker Compose no Easypanel, voce pode criar cada servico individualmente:
Clique para ver o passo a passo manual
Infraestrutura
- Postgres: + Service > Databases > Postgres 16. Anote a connection string.
- Redis: + Service > Databases > Redis. Anote a connection string.
- MinIO: + Service > App > Docker Image
- Image:
minio/minio:latest - Command:
server /data --console-address :9001 - Portas:
9000e9001 - Env:
MINIO_ROOT_USER=minioadmin,MINIO_ROOT_PASSWORD=CHANGE_ME - Dominio para porta 9000 (ex:
s3.seudominio.com)
- Image:
API (backend)
-
- Service > App > Github
- Repo:
NetoNetoArreche/instapost, Branch:main - Dockerfile:
packages/api/Dockerfile, Porta:3001 - Dominio:
api.seudominio.com - Env vars:
NODE_ENV=production
PORT=3001
DATABASE_URL=postgres://<user>:<pass>@postgres.openhive.internal:5432/<db>
REDIS_URL=redis://default:<pass>@redis.openhive.internal:6379
JWT_SECRET=CHANGE_ME
JWT_EXPIRES_IN=7d
INTERNAL_SERVICE_TOKEN=CHANGE_ME
MINIO_ENDPOINT=minio.openhive.internal
MINIO_PORT=9000
MINIO_USE_SSL=false
MINIO_ACCESS_KEY=minioadmin
MINIO_SECRET_KEY=CHANGE_ME
MINIO_PUBLIC_URL=https://s3.seudominio.com
MINIO_BUCKET=openhive-images
FRONTEND_URL=https://app.seudominio.com
Web (frontend)
-
- Service > App > Github
- Dockerfile:
packages/web/Dockerfile, Porta:3000 - Dominio:
app.seudominio.com - Env:
API_INTERNAL_URL=http://api.openhive.internal:3001
MCP Server
-
- Service > App > Github
- Dockerfile:
packages/mcp/Dockerfile, Porta:3002 - Dominio:
mcp.seudominio.com - Env:
API_URL=http://api.openhive.internal:3001,API_TOKEN=mesmo_INTERNAL_SERVICE_TOKEN
Renderer
-
- Service > App > Github
- Dockerfile:
Dockerfile.renderer, Porta:3003
Telegram Bot (opcional)
-
- Service > App > Github
- Dockerfile:
packages/bot/Dockerfile - Env:
API_URL=http://api.openhive.internal:3001,API_TOKEN=mesmo_INTERNAL_SERVICE_TOKEN,TELEGRAM_BOT_TOKEN=...,TELEGRAM_ALLOWED_CHAT_IDS=...
Variaveis de Ambiente (.env)
Se voce esta usando Easypanel ou Coolify, IGNORE esta secao. Ela e para desenvolvimento local e VPS com SSH. No Easypanel/Coolify voce so precisa das 5 senhas descritas na secao de instalacao acima.
Referencia completa de variaveis (dev local / VPS)
# === Banco de Dados ===
DB_PASSWORD=senha_forte # Senha do Postgres
DATABASE_URL=postgresql://instapost:SENHA@localhost:5433/instapost # Dev local
# DATABASE_URL=postgresql://instapost:SENHA@postgres:5432/instapost # Docker prod
# === Redis ===
REDIS_URL=redis://localhost:6379 # Dev local
# REDIS_URL=redis://:senha@redis:6379 # Docker prod com senha
# === JWT ===
JWT_SECRET=openssl_rand_hex_32 # Gere com: openssl rand -hex 32
JWT_EXPIRES_IN=7d
# === Token interno (Bot + MCP autenticam na API) ===
INTERNAL_SERVICE_TOKEN=openssl_rand_hex_24 # Gere com: openssl rand -hex 24
# === MinIO (Storage S3) ===
MINIO_ENDPOINT=localhost # Dev: localhost | Docker: minio
MINIO_PORT=9000
MINIO_USE_SSL=false # true se usar HTTPS
MINIO_ACCESS_KEY=minioadmin
MINIO_SECRET_KEY=senha_minio
MINIO_PUBLIC_URL=http://localhost:9000 # URL publica para acessar imagens
MINIO_BUCKET=instapost-images
# === Frontend ===
FRONTEND_URL=http://localhost:3000 # URL do web app
WEB_PORT=3000
# === MCP Server ===
MCP_PORT=3002
# === Geracao de Imagens (Google Gemini) ===
NANO_BANANA_API_KEY= # Chave do Google AI Studio
NANO_BANANA_PROVIDER=google # google | nanobananaapi | fal
# === Instagram (opcional) ===
INSTAGRAM_ACCESS_TOKEN=
INSTAGRAM_USER_ID=
FACEBOOK_APP_ID=
FACEBOOK_APP_SECRET=
# === Telegram Bot (opcional) ===
TELEGRAM_BOT_TOKEN= # Token do BotFather
TELEGRAM_ALLOWED_CHAT_IDS= # IDs dos chats permitidos
Conectar MCP (IDEs e Agentes)
O OpenHive expoe 40 tools via Model Context Protocol. Ha duas formas de conectar:
Opcao 1: MCP Server HTTP (ja incluso no projeto)
Quando voce roda o OpenHive (local ou VPS), o MCP Server HTTP ja sobe automaticamente na porta 3002. Nao precisa instalar nada extra.
URL do MCP:
- Local:
http://localhost:3002/mcp - VPS:
https://mcp.seudominio.com/mcp
Claude Cowork: Personalizar > Conectores > + Adicionar > cole a URL do MCP
Claude Desktop: Settings > MCP Servers > Add Server > cole a URL do MCP
Opcao 2: MCP CLI via npx (para IDEs com Stdio)
Usado pelo Gemini Antigravity, Cursor, VS Code, Claude Code e qualquer IDE que suporte MCP via comando stdio.
Nao precisa instalar nada manualmente. O npx -y baixa e executa o pacote automaticamente. Basta adicionar a configuracao JSON na sua IDE.
O OPENHIVE_API_URL deve apontar pra sua API:
- Se roda local:
http://localhost:3001 - Se roda em VPS:
https://api.seudominio.com
O OPENHIVE_API_TOKEN e o mesmo valor do INTERNAL_SERVICE_TOKEN que esta no seu .env.
Gemini Antigravity (~/.gemini/antigravity/mcp_config.json):
{
"mcpServers": {
"openhive": {
"command": "npx",
"args": ["-y", "openhive-mcp-server@latest"],
"env": {
"OPENHIVE_API_URL": "http://localhost:3001",
"OPENHIVE_API_TOKEN": "seu_INTERNAL_SERVICE_TOKEN"
}
}
}
}
Claude Code (~/.claude/claude_desktop_config.json):
{
"mcpServers": {
"openhive": {
"command": "npx",
"args": ["-y", "openhive-mcp-server@latest"],
"env": {
"OPENHIVE_API_URL": "http://localhost:3001",
"OPENHIVE_API_TOKEN": "seu_INTERNAL_SERVICE_TOKEN"
}
}
}
}
Cursor (.cursor/mcp.json na raiz do projeto):
{
"mcpServers": {
"openhive": {
"command": "npx",
"args": ["-y", "openhive-mcp-server@latest"],
"env": {
"OPENHIVE_API_URL": "http://localhost:3001",
"OPENHIVE_API_TOKEN": "seu_INTERNAL_SERVICE_TOKEN"
}
}
}
}
VS Code (.vscode/mcp.json):
{
"servers": {
"openhive": {
"command": "npx",
"args": ["-y", "openhive-mcp-server@latest"],
"env": {
"OPENHIVE_API_URL": "http://localhost:3001",
"OPENHIVE_API_TOKEN": "seu_INTERNAL_SERVICE_TOKEN"
}
}
}
}
Opcao 3: Plugin Claude Cowork + Skills Antigravity
O plugin inclui skills do OpenHive (carrossel, LinkedIn, Twitter, YouTube, etc) com fluxos guiados. Tambem inclui skills para o Gemini Antigravity.
- Baixe o plugin e as skills
- Extraia numa pasta local
Claude Cowork:
/plugin marketplace add ./caminho/para/openhives-plugin
/plugin install openhives
/reload-plugins
Gemini Antigravity:
Copie os arquivos de skills para ~/.gemini/antigravity/skills/ e reinicie o Antigravity.
Configurar Integracoes
Todas configuradas pela interface web em Configuracoes (menu lateral).
Google Gemini (geracao de imagens e legendas)
- Acesse aistudio.google.com
- Get API Key > Create API Key
- No OpenHive > Configuracoes > Geracao de Imagens (Gemini) > cole e salve
Instagram (publicacao automatica)
- Acesse developers.facebook.com
- Meus Apps > Criar App > tipo Empresa
- No app, Adicionar Produto > Instagram > Configurar
- Funcoes do app > adicione sua conta como Testador do Instagram
- No Instagram, aceite o convite (Config > Apps e sites > Convites)
- Volte ao Facebook > Instagram > Config da API > Gerar token
- No OpenHive:
- Configuracoes > Chaves de API > cole App ID e App Secret
- Contas do Instagram > Adicionar Conta > cole Access Token e User ID
O token e renovado automaticamente a cada 50 dias.
Cloudinary (OBRIGATORIO para publicar no Instagram)
β οΈ Por que e necessario: desde Abril/2026 a API do Meta endureceu o filtro de hostnames para
image_url. Hosts auto-hospedados como*.sslip.io,*.nip.io, dominios com IP literal, R2 dev URLs, S3 default URLs e ate dominios proprios novos com Let's Encrypt valido sao silenciosamente rejeitados comerror_subcode: 2207052("Falha ao baixar midia") mesmo quando a imagem esta publicamente acessivel e em formato valido.Hosts com reputacao alta no Meta (Cloudinary, Imgur, Wikipedia, Unsplash) continuam funcionando. O OpenHive usa o Cloudinary como camada intermediaria: a imagem sai do MinIO/R2/storage local, e mirrorada para o Cloudinary, e a URL
res.cloudinary.come o que vai para a API do Meta.Sem Cloudinary configurado, geracao/edicao funcionam, mas publicar no Instagram falha.
- Cria conta gratuita em cloudinary.com/users/register_free
- Free tier: 25 GB storage + 25 GB bandwidth/mes (cobre milhares de posts)
- Sem cartao de credito
- Confirma o email
- Dashboard > Programmable Media > pega:
- Cloud Name (ex:
dxxxxxxxx) - API Key (15 digitos)
- API Secret (clica em "reveal")
- Cloud Name (ex:
- No OpenHive > Configuracoes > Cloudinary > cola as 3 e salva
Tambem pode setar via env:
CLOUDINARY_CLOUD_NAME=...
CLOUDINARY_API_KEY=...
CLOUDINARY_API_SECRET=...
As imagens originais continuam no seu MinIO/R2 β Cloudinary recebe so uma copia JPEG otimizada (~150 KB/post) na hora de publicar.
Telegram Bot
- No Telegram, fale com @BotFather >
/newbot - Copie o token
- Descubra seu chat ID: fale com @userinfobot
- No OpenHive > Configuracoes > Telegram Bot > cole token e chat ID
YouTube Clips (cookies)
- No Chrome, instale "Get cookies.txt LOCALLY"
- Va ao youtube.com logado > exporte cookies
- No OpenHive > Configuracoes > YouTube Clips > upload do
cookies.txt
MCP Tools (40)
Design Systems (biblioteca de inspiracoes)
| Tool | Descricao |
|---|---|
list_design_systems | Lista 58 inspiracoes visuais (Stripe, Linear, Apple, Notion, Tesla, etc) com paleta, vibe e mood |
get_design_system | Detalhes completos de uma inspiracao (cores, tipografia, principios) |
list_design_system_categories | Categorias disponiveis (fintech, dev-tools, ai, luxury, etc) |
suggest_brand_from_inspirations | Combina 1-5 inspiracoes em uma sugestao de brand pronta para salvar |
Brands
| Tool | Descricao |
|---|---|
list_brands | Lista brands cadastrados (use antes de criar visuais) |
get_brand | Detalhes de um brand especifico |
get_default_brand | Brand padrao do usuario |
create_brand | Cria brand (logo, cores, produtos, tom de voz) |
update_brand | Atualiza brand |
set_default_brand | Define brand padrao |
delete_brand | Remove brand |
Posts
| Tool | Descricao |
|---|---|
create_post | Cria post ou carrossel (image_prompt, image_prompts, image_urls) |
update_post | Edita post (legenda, hashtags, reagendamento automatico) |
create_mixed_carousel | Carrossel misto: capa IA + slides HTML/Template (aceita brand_id) |
list_posts | Lista posts com filtros |
add_image_to_post | Adiciona imagem a post existente (vira carrossel auto) |
schedule_post | Agenda publicacao |
publish_now | Publica imediatamente no Instagram |
Geracao
| Tool | Descricao |
|---|---|
generate_image | Gera imagem via Google Gemini |
generate_caption | Gera legenda e conteudo de slide com Gemini (fallback estatico se sem API key) |
generate_template_image | Gera imagem com template HTML pre-definido |
render_html_to_image | Renderiza HTML/CSS/Tailwind em PNG |
compose_image_with_html_overlay | Combina imagem IA de fundo + HTML/Tailwind overlay com CSS variables do brand (7 variaveis + logo automatico) |
upload_image | Upload de imagem base64 |
get_analytics | Metricas dos posts |
Editor Visual (via web)
| Funcionalidade | Descricao |
|---|---|
| Gerar conteudo com IA | Gera titulo + subtitulo via Gemini baseado no tema |
| Refinar slide com IA | Refina textos com instrucoes em linguagem natural (ex: "mais curto", "tom profissional") |
| Gerar imagem de fundo | Gera imagem por prompt via Gemini direto no editor |
| Templates | 6 templates (hero, content, stat, quote, cta, list) com preview ao vivo |
| Word highlights | Destaque individual por palavra (cor, bold, italic, underline) |
| Cantos configurΓ‘veis | Texto nos 4 cantos + icones + glass effect |
| Aspect ratios | 1:1 (Feed), 4:5 (Retrato), 9:16 (Stories) |
Tarefas
| Tool | Descricao |
|---|---|
create_task | Cria tarefa (gravacao, post, patrocinio) |
list_tasks | Lista com filtros |
update_task | Atualiza tarefa |
delete_task | Remove tarefa |
Projetos
| Tool | Descricao |
|---|---|
create_project | Cria projeto com modulos |
list_projects | Lista projetos |
get_project | Detalhes com modulos e tarefas |
update_project | Atualiza projeto |
delete_project | Remove projeto |
add_module | Adiciona modulo |
update_module | Atualiza modulo |
delete_module | Remove modulo |
Video
| Tool | Descricao |
|---|---|
analyze_youtube_video | Analisa video YouTube (transcreve + detecta momentos) |
cut_youtube_clips | Corta clips verticais com face cam e legendas |
list_video_clips | Lista clips |
Telegram Bot - Comandos
| Comando | O que faz |
|---|---|
/start | Lista todos os comandos |
/gerar [tema] | Gera post com imagem e legenda |
/gerar 3 [tema] | Gera carrossel com 3 imagens |
/novopost | Criacao interativa de post |
/listar | Posts agendados |
/publicar [id] | Publica post |
/agendar [id] [data] [hora] | Agenda post |
/cancelar [id] | Cancela agendamento |
/tarefas | Tarefas dos proximos 7 dias |
/projetos | Lista projetos |
/funis | Lista funis |
/clip [url] | Analisa video do YouTube |
/clipcortar [id] todos | Corta clips |
/template [titulo] | Gera imagem com template |
/status | Status das integracoes |
Como usar
Criar post pela web
Novo Post > digite o tema > IA gera imagem e legenda > revise > publique ou agende
Criar carrossel pelo MCP (HTML)
- O agente gera HTML de cada slide
- Chama
render_html_to_imagepara cada slide > coleta as URLs - Chama
create_post({ image_urls: [url1, url2, ...], caption: "..." })
Criar carrossel pelo MCP (IA)
- Chama
create_post({ image_prompts: ["slide 1", "slide 2", ...], caption: "..." }) - As imagens sao geradas automaticamente via Gemini
Criar carrossel misto (capa IA + slides template)
Pela web: Novo Post > aba Misto > gere a capa com IA e adicione slides template um a um.
Pelo MCP:
create_mixed_carousel({
cover_prompt: "imagem vibrante sobre produtividade",
slides: [
{ title: "Dica 1", subtitle: "...", template: "bold-gradient" },
{ title: "Dica 2", subtitle: "...", template: "minimal-dark" }
],
brand_id: "uuid-do-brand" // opcional - aplica logo + cores automaticamente
})
Brands (identidade visual)
Cadastre suas marcas para aplicar logo, cores e tom de voz automaticamente nos posts.
Pela web:
- Menu lateral > Brands > Novo Brand
- Configure:
- Nome e logo (PNG/JPG/WebP)
- Cor primaria e secundaria (color picker)
- Descricao e tom de voz (educativo, descontraido, etc)
- Site (URL) - agentes de IA podem visitar para pesquisar informacoes do brand
- Instagram (URL do perfil) - agentes podem analisar o estilo visual e de conteudo
- Produtos/servicos (separados por virgula)
- Hashtags padrao
- Marque brand padrao para aplicar automaticamente
Pelo MCP (em qualquer IDE):
- O agente chama
list_brandspara descobrir brands disponiveis - Pega
website_urleinstagram_urlpara pesquisar contexto e estilo - Pergunta qual brand voce quer aplicar no post
- Passa
brand_idparacreate_mixed_carouseloucreate_post - O OpenHive aplica automaticamente:
- Logo no canto inferior direito de cada slide template
- Cores do brand nos templates HTML
- Tom de voz na geracao da legenda
- Hashtags padrao mescladas as hashtags do post
Exemplo de prompt no chat: "Cria um carrossel sobre 5 dicas de produtividade usando o brand Buildix - antes de criar, pesquise no site e Instagram dele pra manter o estilo"
YouTube Clips
- Clips > Novo Clip > cole URL > Analisar
- Espere transcricao e deteccao de momentos
- Selecione momentos > Gerar Clips
- Download dos clips verticais (1080x1920)
Funis de Vendas
Funis > Novo Funil > crie etapas e passos > modo Flow pra arrastar e conectar
Equipe
Equipe > convide por email > defina funcao e paginas permitidas
Licenca
Source Available License β ver LICENSE
Voce pode usar o OpenHive gratuitamente para uso pessoal e interno. NAO e permitido:
- Vender, revender ou distribuir comercialmente
- Modificar e redistribuir como produto proprio
- Oferecer como SaaS para terceiros
- Remover a marca ou renomear
Para licenciamento comercial: helioarreche@gmail.com

