SSD Nodes Learn Hosting plans →
Mga Gabay Matt ConnorNi Matt Connor

Paano i-self-host ang Open Connector para sa AI agents

Patakbuhin ang Open Connector auth gateway sa sariling VPS: pinned image, TLS origin, OAuth callbacks, at backups para hindi humawak ng SaaS token ang agents.

Ano ang ginagawa ng Open Connector para sa isang AI agent

Ang self-hosting ng Open Connector ay naglalagay ng isang auth gateway sa pagitan ng iyong AI agents at ng bawat software as a service (SaaS) API na tinatawagan nila, kaya hindi kailanman nagtataglay ang agent ng provider token. Isa itong source-available gateway mula sa OOMOL Lab. Kasalukuyan itong lisensyado sa ilalim ng binagong Apache 2.0 license na may karagdagang kondisyon. Nananatiling Apache 2.0 ang mga release hanggang v1.9.4. Ipinakilala ang pagbabago sa v1.9.5. Kung magbibigay ka ng hosted o managed service na ang pangunahing halaga ay ang functionality ng OpenConnector, kailangan mo ng commercial license mula sa OOMOL. Tumatakbo ito bilang isang container, iniimbak ang state nito sa iisang SQLite file, at inilalantad ang provider actions sa HTTP at MCP (model context protocol).

Nagsisimula ang problema sa ikalawang integration. May sariling OAuth (open authorization) flow ang bawat provider, sariling tagal ng validity ng refresh token, at sariling mga pangalan ng scope. Ang manu-manong pagkonekta ng limang provider sa isang agent ay nangangahulugan ng limang redirect handler, limang credential store, at limang refresh loop na kailangang tumakbo bago mag-expire ang token. Halos walang nagsusulat ng ganoong code. Sa halip, gumagawa sila ng tig-isang long-lived personal access token para sa bawat service at inilalagay ito sa agent config, environment file, o prompt mismo. Mababasa na ng bawat tool na pinapatakbo ng agent ang token na iyon. Napupunta rin ito sa transcript. Ito ang failure na inilalarawan sa pag-iwas na mailagay ang mga secret sa AI agents.

Hinahati ng auth gateway sa dalawa ang credential. Iniimbak ng gateway ang provider credential at pinapatakbo ang OAuth flow. Nakakakuha ang agent ng runtime token na valid lamang laban sa gateway. Kapag tumawag ang agent ng isang action, kinukuha ng gateway ang nakaimbak na credential, inilalagay ito sa outbound request sa server side, at ibinabalik lamang ang response body. Hindi kailanman natatanggap ng agent ang provider access token. Kaya kung ma-leak ang agent transcript, isang nare-revoke na runtime token lamang ang mawawala sa iyo, sa halip na ang iyong GitHub account.

Ipinapakita sa catalog ang mahigit 1,000 provider at 10,000 prebuilt action. Sariling bilang ito ng proyekto at hindi mo ito mabe-verify mula sa labas. Ang maaari mong i-verify ay ang estruktura: isang HTTP endpoint para sa bawat action, isang nakaimbak na connection para sa bawat provider, at isang token para sa bawat agent. Kung bago pa sa iyo ang agent side nito at hindi pa pamilyar ang mga terminong gaya ng tool call o MCP server, unti-unting binubuo ng staged path sa kung paano matutunan ang AI agents mula sa simula ang loop, mga tool, at safety habit na ipinapalagay ng ganitong gateway na mayroon ka na.

Bakit mag-self-host ng Open Connector sa halip na gumamit ng hosted connector service

Pareho ang ginagawa ng hosted connector service, at hawak nito ang refresh token para sa bawat provider na ikinokonekta mo rito. Ang refresh token para sa Google o GitHub ay isang matagalang cryptographic key na nagbibigay ng access sa iyong mail at mga repository. Kapag na-breach ang hosted service, kasama sa breach ang iyong account. Sa self-hosting, inililipat ang mga rekord na ito sa SQLite sa isang machine na nirerentahan at ina-administer mo. Pinoprotektahan ito ng isang key na hindi kailanman lumalabas sa iyong machine.

Sabihin nang malinaw ang gastos bago magsimula. Ang VPS na ito ang magiging pinakamahalagang server na pinapatakbo mo. Naglalaman ito ng aktibong credentials para sa dose-dosenang service sa iisang file. Kaya dapat pareho ang pag-aasikaso rito sa isang password manager host: firewall na 443 lamang ang inilalantad, walang shared login, may backup na aktuwal mong na-restore kahit isang beses, at may alert kapag hindi na ito sumasagot. Kung hindi mo ilalagay ang password vault mo sa machine na ito, huwag mo ring ilagay dito ang connector.

Mag-pin ng version bago mag-install ng anuman

Bago pa ang Open Connector. Ginagamit ng gabay na ito ang v1.3.3, na inilabas noong 30 July 2026, bilang naka-pin na installation snapshot noong 1 August 2026. Hindi na ito ang pinakabagong release. Nagpa-publish din ang registry ng tip tag, na bina-build mula sa pinakabagong commit sa main.

Sa ganito kabagong project, madalas magbago ang mga moving tag. Maaaring baguhin ng docker compose pull na lumaktaw ng dalawang release ang isang endpoint na kailangan ng iyong agent, at maghapon kang magde-debug na para bang problema ito ng agent. I-pin ang image sa release tag, at mag-upgrade kapag ikaw ang nagpasya, matapos basahin ang release notes.

I-configure ang Open Connector sa likod ng TLS sa sarili mong VPS

Bago magsimula ang container, kailangan mo ng:

  • Docker Engine 28.0.0 o mas bago, kasama ang Compose plugin, sa Ubuntu 24.04 o malapit dito
  • hostname na ang A record ay nakaturo sa VPS na ito, halimbawa connect.example.com
  • reverse proxy na may TLS (transport layer security) termination na para sa hostname na iyon
  • dalawang random secret na bubuuin sa ibaba

Sinasaklaw ng Traefik reverse proxy para sa maraming Docker Compose app ang bahagi ng proxy. Ang buong proseso ng certificate plumbing, mula simula hanggang dulo para sa isang app, ay nasa gabay na n8n sa VPS gamit ang Docker at HTTPS.

Buuin muna ang mga secret. Pinoprotektahan ng encryption key ang mga nakaimbak na credential. Pinoprotektahan naman ng admin token ang web console at ang buong /api surface. Walang default ang alinman sa mga ito, at maayos na nagsisimula ang runtime kahit wala ang mga ito.

mkdir -p ~/open-connector && cd ~/open-connector
umask 077
printf 'OOMOL_CONNECT_ENCRYPTION_KEY=%s\n' "$(openssl rand -base64 32)" > .env
printf 'OOMOL_CONNECT_ADMIN_TOKEN=%s\n' "$(openssl rand -base64 32)" >> .env
chmod 600 .env

Kopyahin agad ang dalawang value sa password manager mo bago ang unang pagsisimula. Walang recovery path ang encryption key. Ipinaliliwanag ang dahilan sa failure list sa ibaba.

Ngayon, compose.yaml. Naiiba ito sa upstream example sa dalawang bahagi, at parehong mahalaga ang mga ito.

services:
  connector:
    image: ghcr.io/oomol-lab/open-connector:v1.3.3
    restart: unless-stopped
    ports:
      - "127.0.0.1:3000:3000"
    volumes:
      - connector-data:/app/data
    environment:
      OOMOL_CONNECT_DATA_DIR: /app/data
      OOMOL_CONNECT_ORIGIN: "https://connect.example.com"
      OOMOL_CONNECT_ENCRYPTION_KEY: "${OOMOL_CONNECT_ENCRYPTION_KEY:?set this in .env}"
      OOMOL_CONNECT_ADMIN_TOKEN: "${OOMOL_CONNECT_ADMIN_TOKEN:?set this in .env}"

volumes:
  connector-data:

Ang unang pagbabago ay ang naka-pin na tag sa halip na latest. Ang ikalawa ay ang port. Ipinapublish ng upstream file ang 3000:3000, na nagbi-bind sa bawat interface sa host. Isinusulat ng Docker ang mga published port nito sa NAT (network address translation) table bago pa makita ng ufw filter chain ang packet. Kaya hindi isinasara ng ufw deny 3000 ang port na iyon. Ito ang trap na inilalarawan sa kung bakit nilalampasan ng Docker ports ang ufw. Kapag isinulat ang 127.0.0.1:3000:3000, sa loopback interface lamang nagpa-publish, at kumokonekta ang reverse proxy mula sa parehong host. Bago ang Docker Engine 28.0.0, maaaring maabot ng mga host sa parehong L2 segment ang mga port na naka-publish sa localhost. Ito ang dahilan kung bakit kailangan sa gabay na ito ang 28.0.0 o mas bago.

Minamarkahan ng :? ang bawat variable bilang required. Dahil dito, tumatangging magsimula ang stack kapag nawawala ang .env, sa halip na magsimula nang hindi naka-encrypt ang mga credential. Ang pagpapanatili ng mga value sa .env sa halip na sa compose file ay pattern mula sa Docker Compose env files at secrets. Panatilihing private ang /v1 at /mcp sa reverse proxy hanggang sa makagawa ka ng unang runtime token sa ibaba.

docker compose up -d
docker compose logs -n 30 connector
curl -s http://127.0.0.1:3000/health
sudo ss -tlnp | grep 3000

Sinasagot ng /health ang { "ok": true } kapag gumagana na ang runtime. Dapat mag-print ang ss ng 127.0.0.1:3000. Ang linyang 0.0.0.0:3000 ay nangangahulugang naka-bind ang listener sa bawat IPv4 interface, pero hindi nito pinatutunayang maaabot ito mula sa internet. Maaari pa ring humarang sa external traffic ang upstream firewall o ang mga rule sa DOCKER-USER chain ng Docker. Kapag connection refused ang health check, hindi pa nakikinig ang container. Basahin muna ang logs bago galawin ang proxy.

Mga Traefik label para sa parehong service
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.connector.rule=Host(`connect.example.com`)"
      - "traefik.http.routers.connector.entrypoints=websecure"
      - "traefik.http.routers.connector.tls.certresolver=le"
      - "traefik.http.services.connector.loadbalancer.server.port=3000"

Kapag tumatakbo ang Traefik sa Docker sa parehong host, idagdag ang service na ito sa Traefik network at burahin ang ports: block. Inaabot ng Traefik ang container sa internal network, kaya walang kailangang i-publish sa host. Kailangang tumugma ang certresolver=le sa resolver name sa static config ng Traefik. Kung hindi, magsisimula ang router nang walang certificate.

Bakit kailangan ng tamang origin ang OAuth callbacks

OOMOL_CONNECT_ORIGIN ang setting na madalas hindi napapansin, at kapag hindi ito itinakda, nasisira ang OAuth sa paraang mukhang bug ng provider. Binubuo ng runtime ang redirect URI mula sa origin na iyon, sa anyong <origin>/oauth/callback. Kapag hindi ito itinakda, nagiging http://localhost:3000 ang default na origin. Kaya ipinapadala ng runtime sa provider ang redirect URI na http://localhost:3000/oauth/callback, samantalang naka-register sa iyong OAuth app ang https://connect.example.com/oauth/callback. Magkaiba ang dalawang string, kaya ganito ang sagot ng GitHub:

The redirect_uri MUST match the registered callback URL for this application.

Nagre-redirect ang OAuth provider ng browser pabalik sa URI na iyon, kaya dapat itong maabot ng browser. Hindi laging kailangan ng OAuth ng public hostname: idinodokumento ng OpenConnector ang mga GitHub callback sa http://localhost:3000/oauth/callback. Gumagamit ang deployment na ito sa VPS ng hostname at certificate para maabot ng browser ang gateway sa HTTPS origin nito. Itakda ang origin bago ang unang pagsisimula, dahil binabasa ang value sa startup: pagkatapos i-edit ang .env o compose.yaml, patakbuhin muli ang docker compose up -d para mailapat ito.

Ikonekta ang una mong provider gamit ang OAuth

Unang gawin ang OAuth app sa provider. Sa GitHub, pumunta sa Settings, pagkatapos ay Developer settings, OAuth Apps, at New OAuth App. Itakda ang authorization callback URL sa https://connect.example.com/oauth/callback. Itago ang client ID at client secret.

Dala ng bawat /api call ang admin token, kaya isang beses mo itong i-export para sa shell session.

export ADMIN_TOKEN='paste-the-admin-token'
curl -s https://connect.example.com/api/oauth/configs \
  -H "authorization: Bearer $ADMIN_TOKEN"

Ipinapakita ng listing na iyon ang redirect URI na inaasahan ng runtime para sa bawat provider. Ito ang pinakamabilis na paraan para tiyaking naging aktibo ang iyong origin. Kung localhost pa rin ang ipinapakita, tumatakbo ang container gamit ang dating value at mabibigo ang OAuth flow sa huling hakbang.

I-store ang client credentials, pagkatapos ay magsimula ng authorization.

curl -s -X PUT https://connect.example.com/api/oauth/configs/github \
  -H "authorization: Bearer $ADMIN_TOKEN" \
  -H 'content-type: application/json' \
  -d '{"clientId":"...","clientSecret":"..."}'

curl -s -X POST https://connect.example.com/api/oauth/authorizations \
  -H "authorization: Bearer $ADMIN_TOKEN" \
  -H 'content-type: application/json' \
  -d '{"service":"github"}'

Nagbabalik ang ikalawang call ng authorizationUrl. Buksan ito sa browser, aprubahan ang scopes, at ibabalik ng provider ang browser sa /oauth/callback. Doon ipinagpapalit ng runtime ang code at ini-store ang credential. Ipinapakita ng web console sa iyong origin ang parehong mga hakbang gamit ang form at sa ilalim ng parehong admin token. Nilalaktawan ng mga provider na plain API key ang lahat ng ito: direktang ini-store ng PUT /api/connections/<service> kasama ang {"authType":"api_key","values":{"apiKey":"..."}} ang key.

Magbigay ng runtime token sa bawat agent, hindi ng credential

Nag-a-authenticate ang agent sa gateway gamit ang runtime token na ginagawa ng admin API.

curl -s -X POST https://connect.example.com/api/runtime-tokens \
  -H "authorization: Bearer $ADMIN_TOKEN" \
  -H 'content-type: application/json' \
  -d '{"name":"research-agent"}'

May token sa response na nagsisimula sa oct_. Mag-isyu ng tig-iisang token para sa bawat agent at pangalanan ito batay sa agent na iyon. Kapag nag-revoke ka ng token na hindi mo matukoy, kailangan mong i-revoke ang lahat ng token. Pagkatapos, tumatawag ang agent sa mga action gamit ang karaniwang HTTP.

curl -s -X POST https://connect.example.com/v1/actions/github.get_current_user \
  -H "authorization: Bearer oct_..." \
  -H 'content-type: application/json' \
  -d '{"input":{}}'

Ang wastong response ay isang envelope na ang field na success ay true, at nasa data ang payload mula sa provider. Wala saanman sa response na iyon ang GitHub token. Para sa MCP client, ituro ito sa https://connect.example.com/mcp gamit ang parehong bearer header. Nagbibigay ang gateway ng mga discovery tool gaya ng search_actions at execute_action sa halip na tig-isang tool para sa bawat API. Dahil dito, nananatiling maliit ang listahan ng tool ng agent. Sinasaklaw ng Pagpapatakbo ng MCP servers sa VPS ang bahagi ng client sa wiring na ito.

Magsagawa ng isa pang check bago mo sabihing tapos na ito. Ulitin ang action call matapos tanggalin ang authorization header. Tinatawag ng sariling quickstart ng proyekto ang /v1 nang walang bearer, kaya ang installation na walang naka-configure na runtime authentication ay magsasagawa ng mga action para sa sinumang makakaabot sa port. Kung magtagumpay ang unauthenticated call, mayroon kang dalawang paraan: mag-configure ng runtime tokens at tiyaking nabibigo na ngayon ang anonymous call, o paghigpitan ang /api, /v1 at /mcp sa reverse proxy para sa mga address na pinanggagalingan ng iyong mga agent. Kailangang maabot ng browser na kumukumpleto sa authorization ang /oauth/callback. Hindi ito kailangang buksan sa buong internet.

Limitahan ang listahan ng mga aksyon sa mga kailangan ng agent

Malawak na attack surface ang gateway na may isang libong provider sa likod nito kapag ipinagamit ito sa isang language model. Lalo itong lumalawak kapag nagsimula nang magbasa ang model ng tekstong hindi nito isinulat, dahil maaaring maglaman ng mga instruction ang page na ibinalik ng sarili mong SearXNG instance na sumasagot sa mga web search ng agent at nakatuon ang mga ito sa anumang aksyong maaaring gawin ng agent. Ang parehong pag-iingat na dahilan kung bakit pinipili ng coding agent ang pinakamaliit na gumaganang pagbabago ay dapat ding gamitin sa permissions nito: ibigay lamang ang ilang aksyong aktuwal na kailangan ng trabaho, at wala nang iba. Dalawang control ang nagpapaliit sa saklaw nito.

Tumatanggap ang OOMOL_CONNECT_ALLOWED_ACTIONS ng comma-separated allowlist at nauunawaan nito ang service.* at *. Ang OOMOL_CONNECT_BLOCKED_ACTIONS ang denylist, at ito ang mananaig. Kapag itinakda ang allowlist sa github.get_current_user,github.list_issues, tatanggihan ang bawat iba pang aksyon anuman ang hiling ng agent. Ito ang kaibahan ng simpleng pagkakamali sa isang insidente. May sarili ring action rules ang runtime tokens bukod sa mga global rule, at walang laman sa simula ang kanilang allowedProxies list. Dahil dito, tatanggihan ang POST /v1/proxy/:service hanggang sa bigyan mo ito ng pahintulot. Ipinapasa ng proxy endpoint na iyon ang raw request sa isang provider kasama ang credential mo, kaya panatilihin itong walang laman maliban kung kailangan ito ng isang partikular na agent.

Naka-default ang OOMOL_CONNECT_ALLOW_PRIVATE_NETWORK sa false. Pinipigilan nito ang self-hosted provider connection na tumuro sa private address gaya ng cloud metadata service sa 169.254.169.254 o sa database mo sa parehong network. Panatilihin itong naka-off. I-on lamang ito para sa provider na ikaw mismo ang nagho-host.

I-backup ang server na naglalaman ng lahat ng token

Dalawang bagay ang mahalaga, at walang silbi ang bawat isa kung wala ang isa pa. Ang database sa /app/data/connect.sqlite sa loob ng connector-data volume ang naglalaman ng mga naka-seal na credential. Ang encryption key sa .env ang nagbubukas sa mga ito. Walang maibabalik ang volume backup kung wala ang key, at walang maibabalik ang key kung wala ang volume. Kaya dapat ilagay ang key sa iyong password manager, at dapat isama ang volume sa regular mong backup rotation.

I-stop ang container habang kinokopya ang SQLite file, dahil maaaring ma-restore bilang corrupt na database ang kopyang ginawa habang may write operation.

docker volume ls | grep connector-data
docker compose stop connector
docker run --rm -v open-connector_connector-data:/data -v "$PWD":/backup alpine \
  tar czf /backup/connector-data.tgz -C /data .
docker compose start connector

Ang pangalan ng volume ay iyong project directory na sinusundan ng _connector-data. Kaya naroon ang unang command: i-paste ang aktuwal na pangalan sa ikatlong command. Ipadala ang archive palabas ng VPS gamit ang restic backups mula sa VPS. Ie-encrypt nito ang archive bago ito umalis, dahil ang archive na iyon ang credential store.

Pinananatili ng runtime ang mga kamakailang action run bilang audit record, 5,000 ang default na bilang. Dahil dito, masasabi ng console kung aling agent ang nagpatakbo ng alin at kung kailan. Ang log na iyon ang unang dapat basahin kapag kakaiba ang pagkilos ng isang agent. Ituro rin ang isang Uptime Kuma status page sa https://connect.example.com/health. Kapag hindi na sumasagot ang gateway, maaaring maging malabo ang mga failure ng agent. Kapag alam mong down ang gateway, makakatipid ka ng isang oras sa pagbabasa ng agent output.

Mga nasisira, at ang mensaheng makikita mo

redirect_uri_mismatch sa provider. Magkaiba ang origin at ang registered callback URL. Ihambing ang eksaktong string mula sa /api/oauth/configs sa app settings ng provider, kabilang ang https sa http at anumang trailing slash.

Bawat tawag sa /api ay nagbabalik ng 401. Nawawala o mali ang spelling ng admin token header. Ang header ay Authorization: Bearer <token>, at hinihingi rin ng web console ang parehong token.

Tumatakbo ang container, at plain text ang mga credential. Nangyayari ito kapag hindi nakakarating ang OOMOL_CONNECT_ENCRYPTION_KEY sa container, dahil iniimbak ng runtime ang mga credential record nang hindi naka-encrypt sa halip na tumangging magsimula. Patunayan ito sa sarili mong install: kumonekta ng provider gamit ang API key na makikilala mo, pagkatapos ay hanapin ito sa database.

docker compose cp connector:/app/data/connect.sqlite /tmp/connect.sqlite
grep -c 'github_pat_' /tmp/connect.sqlite
shred -u /tmp/connect.sqlite

Ang count na higit sa 0 ay nangangahulugang hindi ginagamit ang key, kaya tiyaking nasa parehong directory ang .env at compose.yaml at ipinapakita ng docker compose config ang value. Kapag nakatakda na ang key, 0 ang ibinabalik ng parehong search, dahil naka-seal ang record gamit ang AES-256-GCM (advanced encryption standard, 256-bit key, Galois/counter mode).

Walang nade-decrypt pagkatapos ng restore. Nagbago o nawala ang encryption key. Hindi ito kailanman isinusulat katabi ng data, ayon sa disenyo, kaya walang recovery path at walang support ticket na makakatulong. Ikonekta muli ang bawat provider. Sinusuportahan ang key rotation sa pamamagitan ng hiwalay na key variable at data command sa runtime, kaya basahin ang kasalukuyang release notes bago mag-rotate ng anuman.

Nagkakaroon ng error ang agent na tumutukoy sa action na nakikita nito sa catalog. Magkahiwalay ang discovery at execution. Maaaring lumitaw ang isang action sa search_actions ngunit tanggihan pa rin ito ng OOMOL_CONNECT_ALLOWED_ACTIONS, ng denylist, o ng sariling rules ng runtime token na iyon.

Mga upgrade. I-back up ang volume, i-edit ang image tag sa bagong release, pagkatapos ay docker compose pull && docker compose up -d. I-monitor ang docker compose logs -n 50 connector para sa migration line, at patakbuhin muli ang health check at isang aktuwal na action bago ito muling pagkatiwalaan. Ang pag-rollback ay nangangahulugang ibalik ang dating tag, na gagana lamang dahil naka-pin ito.

FAQ

Kailangan ko ba ng public domain para mag-self-host ng Open Connector?

Para sa mga provider na gumagamit ng API key, hindi: sapat na ang gateway sa 127.0.0.1. Hindi rin ito palaging kailangan ng OAuth: idinodokumento ng OpenConnector ang local callback ng GitHub bilang http://localhost:3000/oauth/callback. Kailangang maabot ng browser na kumukumpleto sa authorization ang callback URL. Para sa VPS deployment na ito, itakda ang OOMOL_CONNECT_ORIGIN sa iyong https:// hostname bago ang unang pagsisimula, at i-register ang <origin>/oauth/callback sa OAuth app ng provider.

Ano ang mangyayari kung mawala ang encryption key ng Open Connector?

Hindi maide-decrypt ang mga naka-store na credential, at walang recovery. Sadyang hindi ini-store ang key kasama ng data, kaya walang sinumang may hawak ng database ang makakabasa nito, kasama ka. Ang tanging opsyon mo ay magtakda ng bagong key at muling ikonekta ang bawat provider. Itago ang key sa isang password manager at isama ang database sa backup rotation, dahil kailangan ng restore ang dalawa.

Makikita ba ng AI agent ko ang access token ng provider?

Hindi kapag sa gateway ito tumatawag. Nag-a-authenticate ang agent gamit ang runtime token na nagsisimula sa oct_, at ini-inject ng gateway ang credential ng provider sa outbound request sa server, saka ibinabalik ang response lamang. Dalawang bagay ang sumisira sa property na ito: ang /v1/proxy/:service endpoint, na nagpapasa ng mga raw request na nakakabit ang iyong credential at sadyang walang laman ang grants nito, at ang pag-paste mo mismo ng API key sa agent, na ganap na lumalampas sa gateway.

Dapat bang maabot ang gateway mula sa public internet?

Kailangang maabot ng browser na kumukumpleto sa authorization ang OAuth callback, pero hindi nito kailangan ng access mula sa buong internet. Gamit ang Docker Engine 28.0.0 o mas bago at default bridge networking, i-publish ang container port sa 127.0.0.1 upang ang published port ay ma-access lamang mula sa host, at ilagay sa unahan nito ang reverse proxy. Sa mas lumang Docker release, maaaring maabot ng mga host sa parehong L2 segment ang mga port na naka-publish sa localhost. Pagkatapos, subukan ang isang action call na walang authorization header. Kung magtagumpay ito, paghigpitan sa proxy ang /api, /v1 at /mcp upang ang mga address na ginagamit ng iyong mga agent lamang ang makapag-access, hanggang ang mga authenticated call na lang ang gumana.

Handa na ba ang Open Connector para sa production use?

Gumagamit ang mga kasalukuyang release ng binagong Apache 2.0 license na may karagdagang kondisyon; ang mga release hanggang v1.9.4, kabilang ang naka-pin na v1.3.3, ay nananatiling Apache 2.0. Ang hosted o managed connector service na pangunahing halaga ay ang functionality ng OpenConnector ay nangangailangan ng commercial license mula sa OOMOL sa ilalim ng kasalukuyang license. Ang mga installation command para sa v1.3.3 ay snapshot pa rin noong 1 August 2026, at inilabas ang release na iyon noong 30 July 2026. Patakbuhin ito na naka-pin sa isang release tag, hindi kailanman sa latest o tip, basahin ang release notes bago ang bawat upgrade, at panatilihin ang volume backup na minsan mo nang na-restore. Maayos ang disenyo para sa isang box na pagmamay-ari mo, at ang panganib ay nasa pagbabago-bago ng version, hindi sa architecture.

Nakatulong ba ang artikulong ito?

#ai-agents#oauth#self-hosting#integrations#source-available