Skip to content
Back to search

open-agent-connector

Open-source, self-hosted alternative to Composio, Nango, Merge.dev, and Arcade.dev for AI agent integrations. Run GitHub, Slack, Hacker News, and custom HTTP actions over MCP or REST.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/Anil-matcha/open-agent-connector with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/Anil-matcha/open-agent-connector'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/anil-matcha--open-agent-connector/badge.svg)](/listings/anil-matcha--open-agent-connector)

HTML

<a href="/listings/anil-matcha--open-agent-connector"><img src="/api/listings/anil-matcha--open-agent-connector/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Requirements

- Python 3.11 or newer - Node.js and npm

1. Run the API

cd server
python -m venv venv
source venv/bin/activate
python -m pip install -r requirements.txt
uvicorn main:app --host 127.0.0.1 --port 8000 --reload

On Windows PowerShell, activate the environment with:

venv\Scripts\Activate.ps1

The API creates its SQLite database and a local encryption key on first startup if they do not exist. For a durable deployment, configure and back up a stable key before saving credentials; losing the key makes previously encrypted credentials unreadable.

2. Run the web console

Open another terminal from the repository root:

cd client
npm install
npm run dev

Open [http://localhost:3000](http://localhost:3000). The console uses `http://localhost:8000` for the API by default. Set `NEXT_PUBLIC_API_URL` before starting or building the frontend to use a different API URL.

Local service URLs

- Web console: `http://localhost:3000` - Health check: `http://localhost:8000/health` - Interactive API docs: `http://localhost:8000/docs` - MCP endpoint: `http://localhost:8000/mcp` - MCP tool preview: `http://localhost:8000/mcp/tools`

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 341 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Open Agent Connector
  2. **An open-source, self-hosted integration gateway for AI agents.** Connect accounts to app APIs, keep credentials in your own runtime, and let agents discover and run actions through the Model Context Protocol (MCP) or a REST API.
  3. This project is for developers who want to inspect, run, and extend their own agent integration layer. It is an open-source option to evaluate alongside [Composio](https://composio.dev/), [Nango](https://nango.dev/), [Merge.dev](https://www.merge.dev/), and [Arcade.dev](https://www.arcade.dev/). Those platforms offer broader catalogs and managed capabilities; Open Agent Connector currently prioritizes a compact self-hosted implementation that you can modify.
  4. ## Project description
  5. Open Agent Connector gives an agent a consistent way to discover connected services, find an action, read its input schema, and execute it. A FastAPI backend manages provider definitions, connections, outbound requests, and run records. A Next.js console provides screens for browsing providers and actions, managing connections and runtime tokens, and reviewing activity. SQLite stores application data locally by default, with PostgreSQL supported via SQLAlchemy async and Alembic migrations.
  6. The catalog currently registers **263 providers** with **8,472 actions** (counted from `server/app/providers/registry.py` and `actions_catalog.json`) spanning Developer tools, Project Management & CRM, Communication, Storage, AI/ML, E-Commerce, Social Media, Financial, and Utilities. For a complete list of all 263 providers, auth types, action counts, and category classifications, see [PROVIDER_GUIDE.md](PROVIDER_GUIDE.md). Registered does not mean battle-tested: not every provider action or OAuth flow has been verified against a live account, so confirm the ones you depend on.
  7. ## Features
  8. - **MCP gateway:** Model Context Protocol (MCP) JSON-RPC 2.0 endpoint over `POST /mcp` and tool discovery over `GET /mcp/tools`. Every remote MCP call fails closed and requires an admin or runtime token with granular scope enforcement.
  9. - **Scoped runtime tokens:** hashed, revocable tokens with deny-by-default action grants plus optional connection and proxy restrictions.
  10. - **OAuth:** authorization URL, state and code exchange, encrypted token storage, and refresh for providers that support OAuth.
  11. - **Action discovery:** agents can list providers, search actions, inspect action guides and schemas, and execute actions.
  12. - **Direct MCP actions:** provider actions are exposed as individual MCP tools (scoped to caller token grants), alongside discovery and execution meta-tools.
  13. - **REST API:** list providers and actions, execute an action, or use a provider proxy where supported.
  14. - **Connections & credentials:** save named provider connections; credential values are encrypted at rest with AES-256-GCM.
  15. - **Local web console:** browse the 263-provider catalog, configure connections, execute test runs, and manage runtime tokens and audit logs.
  16. - **Outbound HTTP safeguards:** SSRF protection with hop-by-hop redirect verification, cross-origin secret stripping, response size caps, and socket-level IP address pinning to eliminate DNS-rebinding attacks.
  17. - **Idempotent execution:** action requests can use an `Idempotency-Key`; matching completed requests return saved responses and detect payload conflicts.
  18. - **Run records:** action executions record duration, HTTP status, and bounded, secret-redacted input/output summaries.
  19. - **Unified catalog:** 8,472 action schemas maintained in `server/app/providers/actions_catalog.json` and registered through extensible Python providers.
  20. ## How it compares
  21. These products overlap in connecting apps to software and AI agents, but they have different scopes. Composio centers on a large app toolkit and agent execution platform. Nango focuses on building and operating product integrations, including auth and sync. Merge.dev provides unified APIs and common models across product integration categories. Arcade.dev focuses on agent-ready tools, authentication, and runtime controls. Open Agent Connector is a self-hosted integration gateway for teams who want to inspect, own, and customize their agent runtime.
  22. ## Architecture
  23. ```text
  24. Agent or application
  25. │
  26. ├── MCP JSON-RPC: POST /mcp (authenticated)
  27. └── REST: /v1/* (authenticated execution)
  28. │
  29. FastAPI action runtime
  30. ├── provider and action registry (263 providers / 8,472 actions)
  31. ├── principal resolution & deny-by-default policy enforcement
  32. ├── connection & AES-256-GCM credential encryption
  33. ├── DNS-pinned guarded outbound HTTP client (SSRF & rebinding guard)
  34. └── audit run logs and idempotency records
  35. │
  36. SQLite / PostgreSQL database + external provider APIs
  37. │
  38. Next.js web console ────────┘
  39. ```
  40. ### Stack
  41. | Area | Technology |
  42. | --- | --- |
  43. | Web console | Next.js App Router, React, TypeScript, Tailwind CSS |
  44. | API and runtime | FastAPI, Python 3.11+, Pydantic v2 |
  45. | Persistence | SQLite / PostgreSQL, SQLAlchemy async, aiosqlite / asyncpg, Alembic |
  46. | Credential encryption | AES-256-GCM via `cryptography` |
  47. | Agent interface | MCP JSON-RPC 2.0 (HTTP & STDIO transports) |
  48. ## Provider catalog overview
  49. The registry includes 263 providers across 10 functional domains. Below is a representative cross-section:
  50. | Category | Provider count | Representative providers | Auth types |
  51. | --- | --- | --- | --- |
  52. | **Developer & DevOps** | 35+ | GitHub, GitLab, Docker, Kubernetes, AWS, Cloudflare, Sentry, Jira | API Key, OAuth2, Bearer Token |
  53. | **Communication & Marketing** | 40+ | Slack, Discord, Twilio, SendGrid, Mailchimp, WhatsApp, Telegram, ClickSend | OAuth2, Bot Token, API Key |
  54. | **CRM & Sales** | 25+ | HubSpot, Salesforce, Pipedrive, Zoho CRM, Capsule CRM, Close | OAuth2, API Key |
  55. | **Project Management** | 30+ | Notion, Linear, Asana, Trello, ClickUp, Monday, Basecamp, Toggl | OAuth2, API Key, Token |
  56. | **AI & Machine Learning** | 15+ | OpenAI, Anthropic, ElevenLabs, Perplexity, Replicate, Mistral, Groq | API Key |
  57. | **Storage & Cloud** | 20+ | Google Drive, Dropbox, Box, OneDrive, AWS S3, Cloudinary | OAuth2, API Key |
  58. | **E-Commerce & Billing** | 18+ | Shopify, Stripe, PayPal, Square, WooCommerce, Chargebee | OAuth2, API Key |
  59. | **Social Media & Content** | 18+ | Twitter/X, LinkedIn, Reddit, YouTube, Medium, WordPress | OAuth2, API Key |
  60. | **Financial & Accounting** | 12+ | QuickBooks, Xero, FreshBooks, Wave, Plaid | OAuth2, API Key |
  61. | **Utilities & Data** | 20+ | Hacker News, OpenWeatherMap, Mapbox, IPinfo, Custom HTTP | None, API Key |
  62. For the complete 263-provider matrix and action schemas, consult [PROVIDER_GUIDE.md](PROVIDER_GUIDE.md). Provider definitions and action schemas can also be queried programmatically via `GET /v1/providers` and `GET /v1/actions`.
  63. ## Quick start
  64. ### Requirements
  65. - Python 3.11 or newer
  66. - Node.js and npm
  67. ### 1. Run the API
  68. ```bash
  69. cd server
  70. python -m venv venv
  71. source venv/bin/activate
  72. python -m pip install -r requirements.txt
  73. uvicorn main:app --host 127.0.0.1 --port 8000 --reload
  74. ```
  75. On Windows PowerShell, activate the environment with:
  76. ```powershell
  77. venv\Scripts\Activate.ps1
  78. ```
  79. The API creates its SQLite database and a local encryption key on first startup if they do not exist. For a durable deployment, configure and back up a stable key before saving credentials; losing the key makes previously encrypted credentials unreadable.
  80. ### 2. Run the web console
  81. Open another terminal from the repository root:
  82. ```bash
  83. cd client
  84. npm install
  85. npm run dev
  86. ```
  87. Open [http://localhost:3000](http://localhost:3000). The console uses `http://localhost:8000` for the API by default. Set `NEXT_PUBLIC_API_URL` before starting or building the frontend to use a different API URL.
  88. ### Local service URLs
  89. - Web console: `http://localhost:3000`
  90. - Health check: `http://localhost:8000/health`
  91. - Interactive API docs: `http://localhost:8000/docs`
  92. - MCP endpoint: `http://localhost:8000/mcp`
  93. - MCP tool preview: `http://localhost:8000/mcp/tools`
  94. ## Configuration
  95. Backend settings use the `CONNECTOR_` environment prefix. A `.env` file in the `server/` directory is loaded when you launch Uvicorn from that directory.
  96. | Variable | Purpose | Default |
  97. | --- | --- | --- |
  98. | `CONNECTOR_HOST` | API bind address | `127.0.0.1` |
  99. | `CONNECTOR_PORT` | API port | `8000` |
  100. | `CONNECTOR_PUBLIC_ORIGIN` | Public origin used by the service | `http://localhost:8000` |
  101. | `CONNECTOR_DATABASE_URL` | SQLAlchemy async database URL (SQLite or PostgreSQL) | SQLite file under `server/data/connector.db` |
  102. | `CONNECTOR_DATA_DIR` | Application data directory | `server/data/` |
  103. | `CONNECTOR_ENCRYPTION_KEY` | Stable AES-256 key used to encrypt stored credentials | Generated local key file if unset |
  104. | `CONNECTOR_ADMIN_TOKEN` | Bearer token for the admin API and management routes | Generated into `server/data/.admin_token` if unset |
  105. | `CONNECTOR_RUNTIME_TOKEN` | Optional static runtime token for `/v1` and `/mcp` | Unset (persistent DB tokens preferred) |
  106. | `CONNECTOR_EXPOSE_LOCAL_TOKEN` | Let `/api/auth/status` return the admin token to genuine loopback callers (never when proxy headers are present). Set `false` on any network-facing deployment. | `true` |
  107. | `CONNECTOR_ALLOW_PUBLIC_ACCESS` | Let visitors without a token use the console and API in a shared **public sandbox** (their own isolated tenant, never the operator's data). Leave it off on any instance that holds real credentials. | `false` |
  108. | `CONNECTOR_ALLOWED_RETURN_ORIGINS` | Comma-separated origins, besides `CONNECTOR_PUBLIC_ORIGIN`, that a `redirectUri` may point to after OAuth. Anything else is rejected, and the callback only ever redirects to the URL stored when the flow started. | `http://localhost:3000,http://127.0.0.1:3000` |
  109. | `CONNECTOR_ALLOW_PRIVATE_NETWORK` | Allow private network destinations for outbound requests | `false` |
  110. | `NEXT_PUBLIC_API_URL` | API base URL used by the browser frontend | `http://localhost:8000` |
  111. Set `CONNECTOR_ENCRYPTION_KEY` to a strong, stable secret before creating connections in an environment you need to preserve. Back up the key separately from the database and restrict access to both. Do not commit `.env` files or secret values.
  112. ## Connect an account
  113. 1. Start both the API and web console.
  114. 2. Open the **Connections** screen and select any of the 236 providers.
  115. 3. Add the required token, API key, or OAuth credentials and choose a connection alias, such as `default`.
  116. 4. Browse the **Actions** screen to inspect available operations, required scopes, and JSON input schemas.
  117. 5. Generate a scoped runtime token on the **Tokens** screen granting access to selected actions and connection aliases.
  118. 6. Use MCP or the REST API to execute actions securely under that token.
  119. GitHub and Slack credentials are validated against their provider APIs when saved. Hacker News does not require credentials. Custom HTTP can use no auth or a saved API key.
  120. ## MCP usage
  121. Configure an MCP client (such as Claude Desktop, Cursor, or Antigravity) that supports remote HTTP MCP with the local endpoint:
  122. ```json
  123. {
  124. "mcpServers": {
  125. "open-agent-connector": {
  126. "url": "http://localhost:8000/mcp",
  127. "headers": {
  128. "Authorization": "Bearer <runtime-or-admin-token>"
  129. }
  130. }
  131. }
  132. }
  133. ```
  134. A token is required. Unauthenticated, invalid, or revoked tokens receive `401`. Tool discovery and execution are filtered by the token's action and connection grants.
  135. The MCP gateway provides five discovery and execution meta-tools:
  136. - `list_apps`: list providers with display names, categories, and authentication requirements.
  137. - `list_connections`: list configured accounts with safe identities (filtered by token grants).
  138. - `search_actions`: search 8,024 catalog actions by keywords or provider service ID (scoped to token grants).
  139. - `get_action_guide`: retrieve full Markdown parameter documentation and JSON Schema for an action.
  140. - `execute_action`: execute an authorized action with input arguments and target connection alias.
  141. Individual provider actions are also exposed as direct MCP tools (e.g. `github_get_current_user`), dynamically filtered by the caller's authorized action permissions. An action call may include a `connectionName` argument; it defaults to `default`.
  142. ## REST API examples
  143. List providers (catalog browsing is public):
  144. ```bash
  145. curl http://localhost:8000/v1/providers
  146. ```
  147. Search actions across catalog:
  148. ```bash
  149. curl 'http://localhost:8000/v1/actions?service=github&query=issue'
  150. ```
  151. Execute an action with a runtime token:
  152. ```bash
  153. curl -X POST http://localhost:8000/v1/actions/github.get_current_user \
  154. -H 'Authorization: Bearer <runtime-or-admin-token>' \
  155. -H 'Content-Type: application/json' \
  156. -H 'Idempotency-Key: example-request-001' \
  157. -d '{"input": {}, "connectionName": "default"}'
  158. ```
  159. ### Main routes
  160. | Route | Purpose | Authentication |
  161. | --- | --- | --- |
  162. | `GET /v1/providers` | List providers; accepts an optional `category` filter | Public |
  163. | `GET /v1/providers/{service}` | Get a provider and its actions | Public |
  164. | `GET /v1/actions` | Search actions; accepts `query` and `service` filters | Scoped by Bearer token |
  165. | `GET /v1/actions/{action_id}` | Get an action schema and provider details | Scoped by Bearer token |
  166. | `POST /v1/actions/{action_id}` | Execute an action with scoped permissions | Runtime or Admin Bearer token |
  167. | `POST /v1/proxy/{service}` | Use a provider's raw proxy implementation | Runtime or Admin Bearer token |
  168. | `POST /mcp` | MCP JSON-RPC 2.0 endpoint (tools/list & tools/call) | Runtime or Admin Bearer token |
  169. | `GET /mcp/tools` | List MCP tool definitions scoped to caller | Runtime or Admin Bearer token |
  170. | `/api/connections` | Create, list, and delete saved provider connections | Admin Bearer token |
  171. | `/api/runtime-tokens` | Create, list, and revoke runtime token records | Admin Bearer token |
  172. | `/api/runs` and `/api/stats` | Inspect audit run records and execution statistics | Admin Bearer token |
  173. Action execution accepts an `input` object and optional `connectionName`. You can also select a connection with the `x-connector-alias` header. The `Idempotency-Key` header is supported on action execution.
  174. ## Extending the catalog
  175. Providers are registered in `server/app/providers/registry.py`. Built-in implementations live in `server/app/providers/builtins/` and share the base classes in `server/app/providers/base.py`.
  176. To add a new provider action:
  177. 1. Define its stable action ID, display name, description, input JSON schema, and required scopes.
  178. 2. Implement its asynchronous `execute` method using the shared HTTP client and the provider credential passed to it.
  179. 3. Register it from the provider implementation and register the provider in the registry.
  180. 4. Add or update credential validation if the provider requires authentication.
  181. 5. Confirm the action schema works through both the REST API and MCP clients.
  182. Provider actions are maintained in a unified catalog at `server/app/providers/actions_catalog.json`, partitioned by provider service ID for scalable expansion.
  183. ## Data and security notes
  184. - The default database and generated local key are stored under `server/data/`; keep this directory out of source control and protect it in backups.
  185. - Connection credentials and OAuth tokens are encrypted at rest with AES-256-GCM. The database alone is not sufficient to recover them; the encryption key must also be preserved securely.
  186. - Outbound requests check resolved IP addresses and block private or internal destinations by default. The `CONNECTOR_ALLOW_PRIVATE_NETWORK` option relaxes some private-address blocking and should be used only in a controlled environment. Loopback, link-local, and metadata addresses remain blocked.
  187. - Run logs keep bounded summaries of action inputs and outputs with sensitive credentials automatically redacted.
  188. - **Authentication is enforced per route:**
  189. | Routes | Credential |
  190. | --- | --- |
  191. | `/api/*` (connections, runtime tokens, runs, stats, OAuth config and authorize) | Admin token |
  192. | `POST /v1/actions/{id}`, `POST /v1/proxy/{service}` | Runtime or admin token, plus action, connection, and proxy grants |
  193. | `POST /mcp`, `GET /mcp/tools` | Runtime or admin token (fail closed) |
  194. | `GET /v1/providers`, `GET /v1/actions`, `/health`, `/docs`, OAuth callback, `/api/auth/status` and `/api/auth/verify` | Public. These expose catalog metadata or the OAuth redirect, not credentials. |
  195. - **Outbound HTTP / SSRF Defense**: All outbound provider calls execute through `GuardedTransport`, which validates target IP addresses and pins TCP connections directly to the vetted IP, preventing DNS rebinding (TOCTOU) attacks while preserving TLS SNI and certificate validation. Private subnets, loopback, link-local, and cloud metadata (e.g. AWS/GCP `169.254.169.254`) are strictly blocked.
  196. - **Behind a reverse proxy**, set `CONNECTOR_EXPOSE_LOCAL_TOKEN=false`, bind the API to loopback or a private network, terminate TLS at the proxy, and rate-limit `/api/auth/verify`. See `docker-compose.prod.yml` for a loopback-only overlay.
  197. - **Database Portability & Deployment**: Backed by SQLite async by default with auto-migration, with PostgreSQL supported via SQLAlchemy async and versioned Alembic migrations (`alembic upgrade head`). A single-instance deployment is recommended until distributed locking and replication coordination are configured across multiple instances.
  198. ## Tenancy
  199. Every tenant-owned row (connections, OAuth state, runtime tokens, run logs, idempotency records) carries a
  200. `tenant_id`. A self-hosted install uses a single `default` tenant, so nothing changes for you. The core
  201. enforces the boundary on every query: services take `tenant_id` as a required argument, and a tenant id
  202. only ever comes from the authenticated principal or from server-side state created for it (for example the
  203. OAuth state record), never from request input.
  204. - Connection names are unique per tenant, so two tenants can each have a `github` / `default` connection.
  205. - OAuth client credentials a tenant supplies are stored per tenant. Credentials from the server
  206. environment belong to the operator and are used only by the `default` tenant.
  207. - Unauthenticated visitors (only when `CONNECTOR_ALLOW_PUBLIC_ACCESS` is turned on; it is off by default) live in a separate `public` tenant
  208. and never see the operator's data.
  209. - A multi-user or hosted layer plugs in through two hooks in `app.core.tenancy`:
  210. `register_principal_resolver(...)` maps its own credentials (API keys, sessions) to a `Principal` with a
  211. `tenant_id` (kind `tenant_admin` for the management API, `runtime` for agents), and
  212. `register_token_extractor(...)` lets it read a credential from somewhere other than the standard headers
  213. (for example a session cookie). A resolver can raise a 401 for a credential it recognises but finds invalid,
  214. so that request never falls back to the public sandbox. Platform-wide hosted OAuth credentials remain
  215. operator-only. The open core itself has no user accounts: it is meant for your own agents, with the admin token
  216. and scoped runtime tokens.
  217. `server/tests/test_tenant_isolation.py` is the contract: two tenants, the operator, and anonymous visitors
  218. try to reach each other's data through every route.
  219. ## Production deployment
  220. ```bash
  221. # .env.prod: PUBLIC_ORIGIN=https://connector.example.com
  222. # ADMIN_TOKEN=<long random value> ENCRYPTION_KEY=<long random value>
  223. docker compose -f docker-compose.yml -f docker-compose.prod.yml --env-file .env.prod up -d --build
  224. ```
  225. This publishes the API on `127.0.0.1:8100` and the console on `127.0.0.1:3100`. Put nginx or another TLS-terminating proxy in front: route `/api`, `/v1`, `/mcp`, `/health`, and `/docs` to the API and everything else to the console. Back up `.env.prod` and the `connector_data` volume together; without the encryption key, saved credentials cannot be decrypted. Run one instance only.
  226. ## Backups
  227. `deploy/backup/connector-backup.sh` takes a consistent snapshot of the SQLite database while the service is
  228. running (SQLite's online backup API), verifies it, keeps 14 days of history, and saves the env file (which holds
  229. `ENCRYPTION_KEY`) whenever it changes. Run it daily from root's cron:
  230. ```bash
  231. 15 3 * * * COMPOSE_DIR=/home/ubuntu/open-agent-connector /home/ubuntu/open-agent-connector/deploy/backup/connector-backup.sh >> /var/log/connector-backup.log 2>&1
  232. ```
  233. Snapshots land in `/var/backups/connector` (override with `BACKUP_DIR`). They protect against corruption and bad
  234. migrations but not against losing the machine, so copy that directory off the host as well. The database holds
  235. credentials encrypted with the key, so **store the key backup separately from the database backup** when you copy
  236. them off the host.
  237. To restore: stop the server, replace the database file in the data volume with a snapshot
  238. (`gunzip -k connector-<time>.db.gz`), and start the server again. Check with `PRAGMA integrity_check` first.
  239. ## Development
  240. Backend dependencies are listed in `server/requirements.txt`. Frontend scripts are defined in `client/package.json`:
  241. ```bash
  242. cd client
  243. npm run lint
  244. npm run build
  245. ```
  246. For API changes, run the backend locally with Uvicorn's reload option and use `/docs` to inspect the generated OpenAPI schema.
  247. Run the in-process MCP authentication regression tests from `server/`:
  248. ```bash
  249. pip install pytest pytest-asyncio
  250. CONNECTOR_ADMIN_TOKEN=test-admin python -m pytest tests/test_mcp_auth_regression.py tests/test_mcp_security.py
  251. ```
  252. ## Project status
  253. Open Agent Connector provides 236 registered providers and 8,024 catalog actions with fail-closed MCP authentication, runtime token authorization, AES-256-GCM encryption, SSRF protection with DNS rebinding defenses, and versioned Alembic database migrations. Contributions that improve provider coverage, documentation, and agent workflows are welcome.
  254. ## License
  255. Open Agent Connector is licensed under the [Apache License 2.0](LICENSE). Unless you state otherwise, any
  256. contribution you submit for inclusion is licensed under the same terms (section 5 of the license).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.