DEV Community: Anthony Max

[Boost]

Anthony Max — Wed, 02 Sep 2026 21:35:07 +0000

Anthony Max

Sep 2

12 Open Source Gems To Become The Ultimate Developer 🔥

#opensource #webdev #javascript #programming

106

5 min read

12 Open Source Gems To Become The Ultimate Developer 🔥

Anthony Max — Wed, 02 Sep 2026 21:33:23 +0000

TL;DR

It's been a while since I've done a collection (maybe month ago), but today let's look at 12 new and not-so-new projects that can really help you in development.

They touch on different areas of development, but we will mainly talk about web development.

If there's a project worth adding to the next collection, feel free to write about it in the comments, and maybe it will be included.

1. 🤖 OpenWork - The open source Claude Cowork alternative.

And we will continue, of course, with AI projects. This tool will allow you to work in one convenient interface with many popular LLMs.

OpenWork is the desktop app that lets you use 50+ LLMs.

💎 Check out the OpenWork repository ☆

2. 💻 T3 Code - The open-source control plane for coding agents.

If you know a YouTuber like Theo, then you should know this project. It's an OpenCode alternative that lets you work with AI in an easy-to-use chat interface.

It enables control of the agents on your machine with a best-in-class mobile app (iOS, Android), web app and Electron-based desktop app.

💎 Check out the T3 Code repository ☆

3. ⚙️ Summarize - Point at any URL or file. Get the gist.

The first project is a small tool for extracting short info of content. Summarize was created by one of the creators of the well-known OpenClaw.

Fast summaries from URLs, files, and media.

💎 Check out the Summarize repository ☆

4. 👾 Godot - Free and open source 2D and 3D game engine

A truly legendary engine like Unity or Unreal Engine for games. If you are a game developer, you should know this project. From pet projects for the university to multi-million dollar games - it gives it all.

Godot Engine is a feature-packed, cross-platform game engine to create 2D and 3D games from a unified interface. It provides a comprehensive set of common tools, so that users can focus on making games without having to reinvent the wheel.

💎 Check out the Godot repository ☆

5. 💎 React Bits - An open source collection of animated, interactive & fully customizable React components.

An excellent collection of components no worse than shad/cn, which will allow you to create a modern design for your website. By the way, hello to David :)

The largest & most creative library of animated React components.

💎 Check out the React Bits repository ☆

6. 🎬 Remotion - Make videos programmatically.

If you would like to make it possible to create videos on your website by writing just one prompt, then this tool is perfect for you.

Create real MP4 videos with React. Use coding agents, build apps and render in bulk.

💎 Check out the Remotion repository ☆

7. 🐈‍⬛ Nest.js - A progressive Node.js framework for building efficient, scalable, and enterprise-grade server-side applications

If you’ve ever wished Express had a bit more structure, Nest.js is the upgrade you’ve been looking for. It brings TypeScript, OOP, and a modular architecture to Node.js development.

Nest is a framework for building efficient, scalable Node.js server-side applications. It uses modern JavaScript, is built with TypeScript (preserves compatibility with pure JavaScript) and combines elements of OOP (Object Oriented Programming), FP (Functional Programming), and FRP (Functional Reactive Programming).

💎 Check out the Nest.js repository ☆

8. ⚙️ GitMCP - free, open-source, remote MCP server for any GitHub project

The following project is a server implementing the MCP protocol that connects LLM directly to a GitHub repository.

GitMCP is a free, open-source, remote Model Context Protocol (MCP) server that transforms any GitHub project (repositories or GitHub pages) into a documentation hub.

💎 Check out the GitMCP repository ☆

9. 🧩 json-render - The Generative UI framework.

The next tool from Vercel allows you to create user interfaces literally from a json object.

Predefined components and actions for safe, predictable output.

💎 Check out the json-render repository ☆

10. 🔀 Flowise - Build AI Agents, Visually.

If you've ever worked with Scratch, then you may be familiar with a slightly similar interface. This project will allow you to create AI agent workflow in a practical builder.

Open source agentic systems development platform.

💎 Check out the Flowise repository ☆

11. 🍎 MLX - An array framework for Apple silicon

An excellent framework from Apple that will allow you to teach your MacBook, iMac and other devices to solve many necessary tasks for business and more.

MLX is designed by machine learning researchers for machine learning researchers. The framework is intended to be user-friendly, but still efficient to train and deploy models. The design of the framework itself is also conceptually simple.

💎 Check out the MLX repository ☆

12. 🔤 Pretext - Fast, accurate & comprehensive text measurement & layout.

Well, the last project, no, not an AI project, but a small javascript library for working with fonts and text at all.

const prepared = prepare(textareaValue, '16px Inter', { whiteSpace: 'pre-wrap' })
const { height } = layout(prepared, textareaWidth, 20)

Pretext side-steps the need for DOM measurements (e.g. getBoundingClientRect, offsetHeight), which trigger layout reflow, one of the most expensive operations in the browser. It implements its own text measurement logic, using the browsers' own font engine as ground truth (very AI-friendly iteration method).

💎 Check out the Pretext repository ☆

🖋️ Conclusion

In this article, I have reviewed only a small part of the volume of projects that are important and even necessary for every developer to know. It is clear that, well, let's say, there are hundreds of such projects today, and maybe more. But I hope you have discovered something new, and if not, at least remembered that there is.

Thank you very much for reading this article ❤️!

What other projects do you know that are not so popular, but also useful? It will be interesting to find out in the comments!

[Boost]

Anthony Max — Sun, 23 Aug 2026 10:25:47 +0000

Anthony Max

Aug 20

Enterprise MCP Gateway Solutions: Providers, Alternatives, and Cost 💎

#ai #webdev #programming #opensource

13 min read

Must read

Anthony Max — Fri, 21 Aug 2026 07:54:22 +0000

Anthony Max

Aug 20

Enterprise MCP Gateway Solutions: Providers, Alternatives, and Cost 💎

#ai #webdev #programming #opensource

13 min read

Enterprise MCP Gateway Solutions: Providers, Alternatives, and Cost 💎

Anthony Max — Thu, 20 Aug 2026 15:58:20 +0000

Your company uses six different AI providers. OpenAI for ChatGPT, Anthropic for Claude and Groq for speed critical inference.

Each one has different API formats. Different authentication models. Different rate limits and costs. Different failure modes.

Your application code has to know about all of them. Your security team has to audit requests across all of them. Your finance team has to track costs across all of them. Your compliance team has to ensure governance across all of them.

Bifrost Gateway solves this by doing what HTTP gateways have done for decades: centralizing control. But for AI.

👀 What is an MCP gateway?

Model Context Protocol (MCP) is an open standard that lets AI models discover and execute external tools at runtime filesystems, web search, databases, ticketing systems, and custom business logic instead of being limited to text generation.

An MCP gateway sits between your applications (or external MCP clients like Claude Desktop and Cursor) and the upstream MCP servers. Instead of each client maintaining its own connections, credentials, and tool lists, the gateway:

Aggregates tools from multiple MCP servers into one registry
Applies governance: authentication, tool filtering, budgets, and rate limits
Exposes a single endpoint that external MCP clients can connect to

In Bifrost, this pattern is implemented in two complementary roles:

Role	What it does
MCP Client	Connects to external MCP servers via STDIO, HTTP, or SSE
MCP Server (Gateway)	Exposes aggregated tools at `/mcp` for Claude Desktop, Cursor, and other MCP-compatible clients

Bifrost is both an AI gateway (routing LLM traffic to 20+ providers) and an MCP gateway (connecting to and exposing tool servers). The open-source gateway covers virtual keys, budgets, rate limits, routing, and MCP tool filtering. Bifrost Enterprise adds RBAC, SSO, audit logs, MCP Tool Groups, guardrails, clustering, and in-VPC deployment options.

⚙️ How does an MCP gateway work?

Connection layer

Each upstream MCP server is registered as an MCP client in Bifrost. Three connection protocols are supported:

Type	Description	Best for
STDIO	Spawns a subprocess, communicates via stdin/stdout	Local tools, CLI utilities, scripts
HTTP	Sends requests to an HTTP endpoint	Remote APIs, microservices, cloud functions
SSE	Server-Sent Events for persistent connections	Real-time data, streaming tools

Authentication is configured separately via a top-level auth_type on each client: none, headers, oauth, per_user_oauth, or per_user_headers. OAuth auth types apply only to HTTP and SSE connections.

Gateway endpoints

When Bifrost acts as an MCP server, external clients connect to:

Endpoint	Method	Purpose
`/mcp`	POST	JSON-RPC 2.0 for tool discovery and execution
`/mcp`	GET	Server-Sent Events for persistent connections

Clients configure their MCP host to point at http://your-bifrost-gateway/mcp, optionally with a virtual key in the Authorization, x-bf-vk, x-api-key, or x-goog-api-key header.

Tool discovery and execution

Tools are discovered when a client connects and refreshed on a configurable sync interval (default 10 minutes). Each tool follows the prefixed naming convention clientName-toolName (for example, filesystem-read_file).

There are two distinct execution models:

1. LLM Gateway path (inference + tools)

When your application calls /v1/chat/completions, Bifrost does not automatically execute tool calls. The default flow is stateless and explicit:

1. POST /v1/chat/completions   → LLM returns tool call suggestions (NOT executed)
2. Your app reviews tool calls → Apply security rules, get user approval if needed
3. POST /v1/mcp/tool/execute   → Execute approved tool calls explicitly
4. POST /v1/chat/completions   → Continue the conversation with tool results

2. Pure MCP Gateway path (Claude Desktop, Cursor, etc.)

When external MCP clients connect directly to /mcp, Bifrost exposes tools over the MCP protocol. The host application (not Bifrost) runs the agent loop and decides whether each tools/call requires user confirmation. Bifrost's tools_to_auto_execute setting only applies in Agent Mode when Bifrost is also running the LLM loop, because it is ignored in pure gateway mode.

Three levels of tool filtering

A tool must pass all applicable filters to be available:

Client config: tools_to_execute on each MCP client (baseline)
Request headers: x-bf-mcp-include-clients and x-bf-mcp-include-tools per request
Virtual key config: mcp_configs array (takes precedence over request headers)

Deny-by-default for virtual keys: when a virtual key has no mcp_configs, no MCP tools are available. Clients not listed in mcp_configs are implicitly blocked.

curl -X POST http://localhost:8080/api/governance/virtual-keys \
  -H "Content-Type: application/json" \
  -d '{
    "name": "staging-key",
    "mcp_configs": [
      {
        "mcp_client_name": "staging_database",
        "tools_to_execute": ["query"]
      }
    ]
  }'

Enterprise: MCP Tool Groups

In Bifrost Enterprise, Tool Groups are reusable bundles of MCP tools attachable to virtual keys, teams, customers, users, providers, or API keys. At request time, Bifrost inspects the request context and exposes only the union of tools from matching groups. This adds a policy layer above per-key configuration for organizations with many teams and use cases.

Health and resilience

Bifrost monitors connected MCP clients with configurable health checks (default: ping every 10 seconds, 5-second timeout, 5 consecutive failures before marking unstable). HTTP/SSE clients reconnect make-before-break; STDIO clients reconnect close-first. Automatic exponential backoff handles transient failures.

🔎 What to evaluate in an MCP gateway

When comparing enterprise MCP gateway solutions, these criteria map directly to what production deployments require:

1. Security posture

Question	Bifrost answer (per docs)
Are tool calls executed automatically?	No by default. Explicit `/v1/mcp/tool/execute` required on the LLM path
Is access deny-by-default?	Yes. Virtual keys with no `mcp_configs` get zero tools
Can you limit tools per team/environment?	Yes. Via virtual key `mcp_configs`, request headers, and Enterprise MCP Tool Groups
Is per-user upstream identity supported?	Yes. `per_user_oauth` and `per_user_headers` with lazy auth

2. Authentication and identity

Evaluate whether the gateway supports both server-level auth (one shared credential for the team) and per-user auth (each end-user connects under their own account). Bifrost supports five auth types, with OAuth limited to HTTP/SSE and implementing Authorization Code flow only (no client-credentials mode).

For enterprise SSO, Bifrost Enterprise provides User Provisioning over OIDC (Okta, Microsoft Entra, etc) with role mapping from IdP groups, app roles, or custom claims, synchronized on each session.

3. Runtime vs administrative governance

This distinction matters: RBAC in Bifrost Enterprise governs the administrative surface (who can edit MCP configs, read logs, configure guardrails) not which tools an agent executes at runtime. Runtime access is controlled by virtual keys, tool filtering, and MCP Tool Groups.

RBAC permissions are Resource × Operation pairs (for example, MCPGateway:Update, AuditLogs:View). Three system roles ship: Admin (42 permissions), Developer (27), Viewer (14).

4. Observability and compliance

Look for request logging, MCP execution logs, and audit trails for configuration changes. Bifrost Enterprise provides:

Audit Logs: signed, filterable administrative event trails with export to JSON, JSON Lines, or Syslog
Log Exports: automated export of request logs to S3, GCS, BigQuery, and other data lakes
Guardrails: PII detection, secrets detection, content safety, and custom regex on LLM traffic and MCP tool executions

5. Cost control at scale

Connecting many MCP servers inflates token usage because classic MCP injects every tool definition on every model turn. Bifrost Code Mode addresses this by having the AI write Python to orchestrate tools in a sandbox rather than exposing hundreds of tool definitions directly. In Bifrost benchmarks with 508 tools across 16 servers, Code Mode reduced input tokens by 92.8% and estimated cost by 92.2% (from $377 to $29 per benchmark round) while maintaining a 100% pass rate.

Virtual keys also provide independent budgets and rate limits for cost management at the key, team, and customer level.

6. Deployment model

Deployment	When to use
Open-source gateway (`npx -y @maximhq/bifrost`)	Local dev, single-node production, full MCP + LLM gateway
Enterprise clustered (3+ pods, PostgreSQL)	HA production with SSO, audit, guardrails
In-VPC	Private-network deployment with no public traffic
Bifrost Edge (alpha)	Endpoint governance — routes AI and MCP traffic from every laptop through your Bifrost without per-app reconfiguration

📊 Alternatives to a dedicated MCP gateway (and their trade-offs)

As MCP adoption moves from local experiments to production, several vendors now offer gateway layers. Each with a different center of gravity. The table below summarizes how the major options compare at a glance; the sections that follow go deeper on each one.

Capability	Bifrost	Docker MCP Gateway	Microsoft	AWS AgentCore Gateway	Kong MCP Gateway
Primary role	Unified LLM + MCP + Agents gateway	Container-native MCP orchestration	K8s MCP proxy + Azure API Management	Managed MCP gateway on Bedrock	API gateway with MCP plugins
MCP client + server	Yes	Client/proxy	Yes (proxy + lifecycle)	Yes	Yes (proxy + REST→MCP conversion)
LLM provider routing	Yes (20+ providers)	No	No	Bedrock-centric	Via separate AI Gateway plugins
Tool filtering / governance	Virtual keys, `mcp_configs`, MCP Tool Groups	Profiles, interceptors	RBAC, APIM policies	Gateway targets, semantic search	OAuth 2.1 + per-tool ACLs
OAuth for MCP servers	Yes (Authorization Code, PKCE, DCR)	Yes (built-in OAuth flows)	Yes (Entra ID)	Yes (IAM + OAuth inbound)	Yes (OAuth 2.1 via AI MCP OAuth2 plugin)
Enterprise audit / RBAC	Yes (Enterprise tier)	Logging + call tracing	Entra RBAC + APIM governance	CloudTrail / IAM	Enterprise-only, Konnect analytics
Open-source option	Yes (full gateway)	Yes (MIT)	Yes (K8s gateway OSS)	Managed AWS service	Gateway OSS; MCP plugins enterprise
Deployment	Binary, Docker, K8s, in-VPC	Docker Desktop / Docker Engine	AKS + Azure APIM	AWS managed	Kong Gateway / Konnect

1. Bifrost

Bifrost is the open-source, high-performance AI gateway built in Go by Maxim AI. It leads this comparison for teams that need LLM routing, MCP aggregation, and agent governance in one self-hosted platform, not an MCP-only proxy sitting beside a separate LLM gateway.

MCP connectivity. Bifrost acts as both MCP client and MCP server. It connects outward to any MCP server you register (STDIO, HTTP, or SSE) and exposes aggregated tools at /mcp for Claude Desktop, Cursor, and other MCP-compatible clients. Five auth types cover the full spectrum: none, headers, oauth, per_user_oauth, and per_user_headers.

Security by default. On the LLM path, Bifrost does not auto-execute tool calls. Your application must explicitly call POST /v1/mcp/tool/execute. Virtual keys enforce deny-by-default: a key with no mcp_configs gets zero MCP tools. Three stacked filter levels (client config, request headers, virtual key config) control which tools each caller sees.

Governance and cost control. Open-source Bifrost covers virtual keys, budgets, rate limits, routing, and MCP tool filtering. Code Mode reduces input token usage by up to 92.8% and estimated cost by 92.2% when orchestrating many MCP servers, the model writes Python to call tools in a sandbox instead of round-tripping every tool definition through the context window. Agent Mode adds opt-in autonomous execution for tools explicitly marked in tools_to_auto_execute.

Enterprise tier. Bifrost Enterprise adds RBAC (Resource × Operation permissions), SSO via OIDC (Okta, Entra, Keycloak, etc), HMAC-signed audit logs, MCP Tool Groups, guardrails (PII, secrets, content safety), clustering, adaptive load balancing, and in-VPC deployment. Enterprise is a strict superset of OSS. Same config.json schema, no re-integration.

Performance. Bifrost adds roughly 11 µs of overhead per request at 5,000 RPS in sustained benchmarks, making it suitable for latency-sensitive production workloads.

Best for: Organizations running mission-critical AI workloads that need a single gateway for LLM traffic, MCP tool access, and agent execution with enterprise-grade governance, air-gapped or in-VPC deployment, and ultra-low latency. Start free with npx -y @maximhq/bifrost; add Enterprise when SSO, audit logs, and administrative RBAC are required.

2. Docker MCP Gateway

Docker MCP Gateway is Docker's open-source (MIT) solution for orchestrating MCP servers as isolated Docker containers. It acts as a centralized proxy: AI clients connect to the Gateway once, and the Gateway manages server lifecycle, credential injection, and routing across servers grouped in profiles.

Strengths: Strong container isolation (restricted privileges, network sandboxing, resource limits), built-in OAuth flows, secrets management via Docker Desktop, dynamic tool discovery, and call-tracing interceptors (secret scanning, signature verification). Integrates natively with Docker Desktop's MCP Toolkit for a low-friction local developer experience.

Trade-offs vs Bifrost: Docker MCP Gateway is MCP-focused, it does not route LLM traffic across providers, enforce virtual-key budgets, or offer Code Mode token savings. Cross-team organizational governance (RBAC, SSO, audit logs) requires additional tooling on top. Best suited for container-native teams already standardized on Docker rather than organizations needing a unified AI + MCP control plane.

Best for: Teams invested in the Docker ecosystem who want to package, run, and secure MCP servers as containers from local development toward production.

3. Microsoft MCP Gateway (Azure)

Microsoft offers two complementary paths for MCP at enterprise scale.

Open-source MCP Gateway is a Kubernetes-native reverse proxy and management layer for MCP servers on AKS. It provides session-aware stateful routing, MCP server lifecycle management (deploy, update, delete), and integration with Azure Entra ID for bearer-token authentication. A separate Tool Gateway handles dynamic tool routing behind the proxy.

Azure API Management adds enterprise governance: expose REST APIs as MCP servers, govern existing MCP endpoints, apply rate-limiting and content-safety policies, and discover servers through Azure API Center. The AI Gateway tier supports MCP-specific features through a dedicated release channel.

Strengths: Deep Azure and Entra ID integration, K8s-native scaling, REST-to-MCP exposure without rewriting APIs, and a mature API-management policy engine.

Trade-offs vs Bifrost: Microsoft's stack is Azure-centric and split across multiple services (AKS gateway + APIM + API Center). It does not unify LLM provider routing with MCP governance in a single binary. Per-tool token-cost optimization (Code Mode) and sub-microsecond LLM gateway overhead are not part of this offering.

Best for: Enterprises already on Azure and Kubernetes who want MCP server lifecycle management and API Management-style policy enforcement within the Microsoft cloud ecosystem.

4. AWS AgentCore Gateway

Amazon Bedrock AgentCore Gateway is AWS's managed MCP gateway for connecting agents to tools hosted on AWS services and external MCP servers. It supports multiple MCP protocol versions (including 2026-07-28 stateless tool calls), semantic search across tool catalogs, and inbound authentication via IAM and OAuth.

Strengths: Fully managed. No gateway pods to size or patch. Native IAM SigV4 for AWS-hosted MCP targets. Semantic search helps agents find the right tool when catalogs grow large. Tight integration with Bedrock agent runtimes and the broader AgentCore platform.

Trade-offs vs Bifrost: AgentCore Gateway is an AWS managed service with Bedrock-centric positioning, not a self-hosted, provider-agnostic LLM gateway. Pricing follows AWS consumption models rather than a free open-source tier. Virtual-key-style budgets, Code Mode orchestration, and air-gapped on-prem deployment are outside this product's scope.

Best for: Teams building agent workloads on Amazon Bedrock who want a managed MCP aggregation layer without operating their own gateway infrastructure.

5. Kong MCP Gateway

Kong MCP Gateway extends Kong's AI Gateway (v3.12+) with MCP-specific plugins. The AI MCP Proxy plugin acts as a protocol bridge. Converting REST APIs into MCP tools (conversion-only / listener modes) or proxying upstream MCP servers in passthrough mode. The AI MCP OAuth2 plugin implements OAuth 2.1 per the MCP authorization spec, mapping token claims to per-tool ACLs.

Strengths: Leverages Kong's proven API-gateway patterns, rate limiting, observability, developer portal, service catalog. Can federate multiple team-owned MCP servers behind one aggregated endpoint with centralized OAuth. REST-to-MCP conversion lets existing Kong-managed APIs become agent tools without new MCP server code.

Trade-offs vs Bifrost: MCP Gateway capabilities are enterprise-only paid plugins on Kong Gateway or Konnect. Not available in the open-source Kong edition. Kong does not natively route LLM traffic across 20+ providers or offer Code Mode token reduction. Configuration spans Services, Routes, Consumers, and plugin modes rather than a unified MCP + LLM config surface.

Best for: Organizations already running Kong API Gateway who want to add MCP aggregation, OAuth 2.1 enforcement, and REST-to-MCP conversion to their existing API-management stack.

💻 What implementing an MCP gateway costs

Costs fall into three buckets: software licensing, infrastructure, and operational/token savings.

Software licensing

Tier	Cost (per docs)	What you get
Open-source Bifrost	Free	LLM gateway, MCP client + server, virtual keys, budgets, rate limits, routing, MCP tool filtering, Code Mode, observability
Bifrost Enterprise	14-day free trial (no credit card); contact sales for pricing	Everything in OSS plus RBAC, SSO, audit logs, MCP Tool Groups, guardrails, clustering, adaptive load balancing, in-VPC deployment, log exports

Bifrost Enterprise is a strict superset of the open-source gateway. Same config.json schema, no re-integration required.

Infrastructure (Enterprise production baseline)

The Enterprise sizing guide recommends:

Gateway pods

Setting	Recommended
Pod count	3 minimum
vCPU per pod	4
RAM per pod	16 GB

PostgreSQL

Configuration	vCPU	RAM
Default (logs in PostgreSQL)	8	24 GB
With object storage for large logs	8	16 GB

Object storage (S3, GCS) for log payloads reduces PostgreSQL write pressure and improves dashboard log-read latency. Audit log archival to object storage is configured separately under audit_logs.object_storage.

For a single-node or development deployment, the open-source gateway runs locally with:

npx -y @maximhq/bifrost

No minimum hardware is specified for OSS. Production Enterprise sizing above is the documented baseline for HA.

Token and inference cost savings

The largest ongoing cost for MCP-heavy workloads is often LLM token usage, not gateway infrastructure. Two Bifrost features directly reduce this:

Code Mode (recommended when using 3+ MCP servers):

Up to 92.8% fewer input tokens vs classic MCP at scale
Up to 92.2% lower estimated inference cost
Benchmark: 508 tools / 16 servers — $377 → $29 per round, 75.1M → 5.4M input tokens

Governance features that reduce waste:

Virtual key budgets — dollar limits with configurable reset periods
Rate limits — token and request throttling per virtual key
Semantic caching — reduces cost and latency for similar queries (open-source feature)
Tool filtering — expose only the tools a team needs, reducing context size even in classic MCP mode

Total cost framing

Scenario	Typical cost drivers
Single team, OSS, local/dev	$0 software + existing hardware; main cost is LLM API usage
Production OSS, single node	Compute for one gateway instance + PostgreSQL (if used) + LLM API usage
Enterprise HA (3 pods + PG + object storage)	Enterprise license + ~3 × (4 vCPU / 16 GB) + PostgreSQL 8 vCPU / 16–24 GB + object storage + LLM API usage
Enterprise + Edge (alpha)	Above + endpoint agent rollout (contact for alpha access)

The gateway itself adds minimal latency. Bifrost benchmarks show 11 µs overhead per request at 5,000 RPS on the LLM routing path. The economic case for an MCP gateway is primarily governance (preventing unauthorized tool access) and token efficiency (Code Mode and filtering at scale), not raw infrastructure savings.

🖋️ Conclusion

An MCP gateway turns a collection of developer tool connections into an organization-wide control plane. Without one, every agent on every laptop can connect to production systems with no central policy, no audit trail, and no cost visibility.

Bifrost provides this as both an open-source AI + MCP gateway and an Enterprise tier for organizations that need RBAC, audit-grade logging, guardrails, and high-availability deployment.

🔗 Resources:

Bifrost GitHub: https://github.com/maximhq/bifrost
Bifrost Docs: https://docs.getbifrost.ai
Bifrost CLI: npx -y @maximhq/bifrost-cli

Thanks for reading this article! ❤️

I'd love to hear your thoughts on this mode in the comments!

[Boost]

Anthony Max — Sat, 15 Aug 2026 07:31:51 +0000

Anthony Max

Aug 14

APIMart: Discounted AI API Aggregator for GPT-5, Sora 2 💎

#ai #webdev #programming #api

3 min read

[Boost]

Anthony Max — Fri, 14 Aug 2026 17:39:40 +0000

Anthony Max

Aug 14

APIMart: Discounted AI API Aggregator for GPT-5, Sora 2 💎

#ai #webdev #programming #api

3 min read

Interesting article

Anthony Max — Fri, 14 Aug 2026 15:14:25 +0000

Anthony Max

Aug 14

APIMart: Discounted AI API Aggregator for GPT-5, Sora 2 💎

#ai #webdev #programming #api

3 min read

APIMart: Discounted AI API Aggregator for GPT-5, Sora 2 💎

Anthony Max — Fri, 14 Aug 2026 13:35:12 +0000

TL;DR

Today, there are numerous AI models, and it's important for businesses to be able to work with them easily and, most importantly, profitably.

Every entrepreneur who runs their own service wants to pay as little as possible for AI tokens and have a personal account with all the keys to the LLM providers' APIs.

Today I would like to introduce you to a site called APIMart, which will help you and your business with this.

Well, let's get started! 🏎️

👀 What is APIMart?

I would say this: if you are looking for a place to buy cheap access to many popular API providers, then this service will help you with that.

Use one OpenAI-compatible API to reach leading global models across text, image, video, and multimodal workloads. APIMart unifies keys, billing, monitoring, and production access so teams can ship AI features faster at a lower operating cost.

⚙️ How to use it?

First of all, when working with APIMart, it's important to understand that it's a user-friendly API. Let's try creating our first connection to an AI model.

To do this, you will need to register on the website:

It won't take more than 5 minutes. Next, let's go to your personal account. Let's say I want to create an image.

By clicking the "Create an API Key" button, I can create my first key that I can use. It's worth noting that you can only specify the API key group and name. Advanced settings are optional.

After creating an API key, you can select the model to use for image generation. I'll be using gpt-image-2 from OpenAI, but you can choose any model that suits your pricing and needs.

It's also worth noting that you can use the free tariff for the model to see if it's right for you.

📚 Documentation

After we've set up our API key, we can now use the model via the API. There's a tab on the model page for this. Clicking on it will take us to the documentation page.

There's a lot written here about how to use the model, but if anything is missing, the documentation is actively updated.

To access the API, let's try typing the following line in the terminal:

# model can be "gpt-image-2", or the compatible alias "gpt-image-2-ext"
curl --request POST \
  --url https://api.apimart.ai/v1/images/generations \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "gpt-image-2",
    "prompt": "Make an image for the article",
    "n": 1,
    "size": "16:9",
    "resolution": "2k"
  }'

If everything is configured correctly, we'll get the generated image.

const url = "https://api.apimart.ai/v1/images/generations";

const payload = {
  model: "gpt-image-2",
  prompt: "Make an image for the article",
  n: 1,
  size: "16:9",
  resolution: "2k"
};

const headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
};

fetch(url, {
  method: "POST",
  headers: headers,
  body: JSON.stringify(payload)
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

It's worth noting that the API can be accessed from any programming language that supports HTTP requests. So, for example, here's what it would look like using JavaScript.

💬 Feedback

If you have questions about the site's operation or want to learn about new features, you can always find them in the community's official project channels:

Or write directly in the form on the website, which is also convenient:

🖋️ Conclusion

APIMart is a great solution for entrepreneurs and companies looking to optimize their AI service costs and simplify their workflow across various models. Instead of managing multiple API keys from different providers, you get a single, convenient interface with your personal account.

🔗 Resources:

APIMart site: https://apimart.ai/register?aff=yScTCM

Thanks for reading this article! ❤️

I'd love to hear your thoughts on this mode in the comments!

[Boost]

Anthony Max — Thu, 06 Aug 2026 21:56:32 +0000

Anthony Max

Aug 5

Enterprise MCP Gateway with Built-In Security: OAuth 2.0, RBAC, and Tool Access Control

#ai #webdev #programming #opensource

8 min read

[Boost]

Anthony Max — Wed, 05 Aug 2026 21:38:18 +0000

Anthony Max

Aug 5

Enterprise MCP Gateway with Built-In Security: OAuth 2.0, RBAC, and Tool Access Control

#ai #webdev #programming #opensource

8 min read

Enterprise MCP Gateway with Built-In Security: OAuth 2.0, RBAC, and Tool Access Control

Anthony Max — Wed, 05 Aug 2026 19:41:55 +0000

TL;DR

MCP servers are powerful, but they can provide access to production systems if anyone on the team can connect and run tools without guardrails.

Imagine a new hire testing the app on their laptop and accidentally granting an MCP server access to the production database. Without governance, that is a realistic path to data leakage.

Bifrost addresses this with three layers:

Human-in-the-loop execution — Bifrost does not auto-execute tool calls. The LLM only suggests tools; your application reviews them and explicitly calls POST /v1/mcp/tool/execute.
Deny-by-default tool filtering — A virtual key with no mcp_configs gets zero MCP tools. Unlisted clients are implicitly blocked.
Governance (optional) — RBAC, SSO, audit logs, and MCP Tool Groups control who can configure the gateway and review administrative activity.

Bifrost covers virtual keys, budgets, rate limits, routing, and MCP tool filtering, RBAC, SSO, audit logs, and MCP Tool.

🔧 Using MCP server

First, let's open the app and set up the MCP server. To do this, I'll enter the following line in the terminal:

npx -y @maximhq/bifrost

After that, you will see the following interface (similar, depending on the version):

Go to the "MCP Library" tab and you will see a huge list of pre-configured MCP servers that you can use in your projects.

If you want to set up your own MCP server, go to MCP Gateway and click New MCP Server:

Here you can specify the connection URL, auth type, tool allowlists, and other settings including Code Mode, which can significantly reduce token usage when orchestrating many MCP servers.

💎 Star Bifrost ☆

⚙️ Human-in-the-loop tool

This is the most important security property for the scenario in the introduction.

When an LLM returns tool calls, Bifrost does not automatically execute them. Tool calls are suggestions only. Your application must explicitly approve and execute each one:

1. POST /v1/chat/completions   → LLM returns tool call suggestions (NOT executed)
2. Your app reviews tool calls → Apply security rules, get user approval if needed
3. POST /v1/mcp/tool/execute   → Execute approved tool calls explicitly
4. POST /v1/chat/completions   → Continue the conversation with tool results

Example execution call:

curl -X POST http://localhost:8080/v1/mcp/tool/execute \
  -H "Content-Type: application/json" \
  -d '{
    "id": "call_xyz789",
    "type": "function",
    "function": {
      "name": "database_query",
      "arguments": "{\"sql\": \"SELECT 1\"}"
    }
  }'

So even if a new hire's agent requests a dangerous database operation, nothing happens until your application deliberately executes it. Combined with deny-by-default virtual key filtering (below), this is Bifrost's real three-layer answer to accidental production access.

You can opt into autonomous execution for specific tools via Agent Mode, but that must be explicitly configured, it is not the default.

💻 MCP authentication

Authentication is declared on the MCP client itself as a top-level auth_type field, posted to /api/mcp/client. There is no nested auth object.

`auth_type`	Who authenticates	When to use
`none`	—	Public MCP servers, local STDIO tools
`headers`	Admin, once	Shared API keys, bearer tokens, custom headers
`oauth`	Admin, once	Shared third-party service the whole team uses
`per_user_oauth`	Each end-user, lazily	Per-user services like Notion, GitHub, Sentry
`per_user_headers`	Each end-user, lazily	Per-user API keys, signed tokens

OAuth (oauth and per_user_oauth) is only valid for HTTP and SSE connections. Bifrost implements the Authorization Code flow, there is no client-credentials / service-account mode.

1. No auth (development only)

{
  "name": "local-tools",
  "connection_type": "stdio",
  "stdio_config": {
    "command": "npx",
    "args": ["-y", "@anthropic/mcp-filesystem"]
  },
  "auth_type": "none",
  "tools_to_execute": ["read_file", "list_directory"]
}

2. Static headers (shared API keys)

curl -X POST http://localhost:8080/api/mcp/client \
  -H "Content-Type: application/json" \
  -d '{
    "name": "web_search",
    "connection_type": "http",
    "connection_string": "https://mcp.example.com/mcp",
    "auth_type": "headers",
    "headers": {
      "Authorization": "Bearer your-api-key",
      "X-Tenant-ID": "acme-corp"
    },
    "tools_to_execute": ["*"]
  }'

3. Server-level OAuth (admin authorizes once)

The admin authenticates once during setup. Every subsequent request to that MCP server uses the same stored token, regardless of which caller hit Bifrost.

curl -X POST http://localhost:8080/api/mcp/client \
  -H "Content-Type: application/json" \
  -d '{
    "name": "authenticated_service",
    "connection_type": "http",
    "connection_string": "https://api.example.com/mcp",
    "auth_type": "oauth",
    "oauth_config": {
      "client_id": "your-client-id",
      "client_secret": "your-client-secret",
      "authorize_url": "https://auth.example.com/oauth/authorize",
      "token_url": "https://auth.example.com/oauth/token",
      "scopes": ["mcp:read", "mcp:write"]
    },
    "tools_to_execute": ["*"]
  }'

The oauth_config object accepts client_id, client_secret, authorize_url, token_url, scopes, or registration_url / server_url for Dynamic Client Registration. After the admin completes the authorize step, finalize with POST /api/mcp/client/{id}/complete-oauth.

4. Per-user OAuth (each user authenticates themselves)

Use auth_type: "per_user_oauth" when each end-user must connect under their own account. Bifrost stores one OAuth token per (identity, mcp_client) and reuses it on later calls. Identity is required via virtual key, signed-in SSO user, or x-bf-mcp-session-id.

5. Per-user headers (legacy / custom per-user keys)

curl -X POST http://localhost:8080/api/mcp/client \
  -H "Content-Type: application/json" \
  -d '{
    "name": "acme_api",
    "connection_type": "http",
    "connection_string": "https://api.acme.example.com/mcp",
    "auth_type": "per_user_headers",
    "per_user_header_keys": ["X-API-Key", "X-Tenant-ID"],
    "tools_to_execute": ["*"]
  }'

Identity matters: With auth_type: "oauth" or auth_type: "headers", all callers share the same upstream credential. Bifrost does not attach a per-user identity to MCP requests. To know exactly who performed an action upstream, use per_user_oauth or per_user_headers.

💻 Runtime tool access control (Virtual Keys)

RBAC does not govern which MCP tools an agent can invoke at runtime. That is controlled by virtual keys and three stacked levels of tool filtering:

Client config — tools_to_execute on each MCP client (baseline)
Request headers — x-bf-mcp-include-clients and x-bf-mcp-include-tools per request
Virtual key config — mcp_configs array (takes precedence over request headers)

Deny-by-default

This is built-in behavior, not a config setting: a virtual key with no mcp_configs gets zero MCP tools, and clients not listed in mcp_configs are implicitly blocked.

Virtual key configuration

curl -X POST http://localhost:8080/api/governance/virtual-keys \
  -H "Content-Type: application/json" \
  -d '{
    "name": "new-dev-key",
    "mcp_configs": [
      {
        "mcp_client_name": "internal_api",
        "tools_to_execute": ["search", "get_article"]
      },
      {
        "mcp_client_name": "staging_database",
        "tools_to_execute": ["query"]
      }
    ]
  }'

`tools_to_execute`	Result
`["*"]`	All tools from this client
`["a", "b"]`	Only specified tools
`[]`	No tools from this client
Client not in `mcp_configs`	All tools blocked from that client

This is where you enforce patterns like "backend devs can hit staging APIs but not production databases" by giving different virtual keys different mcp_configs, not by RBAC permission strings.

Per-request narrowing

For one-off restrictions within a virtual key's allowlist:

curl -X POST http://localhost:8080/v1/chat/completions \
  -H "Authorization: Bearer vk_new_dev" \
  -H "x-bf-mcp-include-tools: staging_database-query" \
  -d '...'

Note: when a virtual key has mcp_configs, it auto-generates x-bf-mcp-include-tools and overrides any manually sent header.

Bifrost does not parse SQL or block operations like DELETE / DROP at the query level. Restrict access by allowing only specific tool names (for example, a read-only query tool instead of an execute tool).

🔎 RBAC — administrative access

Bifrost provides Role-Based Access Control for the administrative surface who can edit MCP gateway configs, read logs, configure guardrails, manage virtual keys, and so on. RBAC is not runtime authorization for agents invoking MCP tools.

Permissions are Resource × Operation pairs, not permission strings like mcp:tool:invoke.

System roles

Role	Permissions	Description
Admin	42	Full access to all resources and operations
Developer	27	CRUD on technical resources, view access to logs and cluster
Viewer	14	Read-only access to all resources

You can also create custom roles (for example, an Auditor role with AuditLogs:View and Logs:View only).

Protected resources include

Logs, VirtualKeys, MCPGateway, MCPToolGroups, MCPLogs, GuardrailsConfig, AuditLogs, Cluster, and others.

Operations include

View, Create, Update, Delete, Download, Reveal, and inference operations.

Example: a custom Auditor role might grant AuditLogs:View and AuditLogs:Download, but not MCPGateway:Update. That controls who can configure the gateway in the dashboard, not which tools an agent executes at runtime.

Roles and permissions are managed via Governance → Roles & Permissions in the dashboard or the /api/roles endpoints:

curl -X GET http://localhost:8080/api/roles/{role_id}/permissions \
  -H "Authorization: Bearer <admin_token>"

🖥️ User Provisioning and role mapping

There is no role_sync config block. Role assignment comes from User Provisioning over OIDC, supported for Okta, Microsoft Entra and others.

When SSO is configured:

Users sign in with corporate credentials via OAuth 2.0 / OIDC (Authorization Code + PKCE)
Roles are mapped from IdP groups, app roles, or custom claims to Bifrost roles (Admin, Developer, Viewer, or custom roles)
Role and team assignments are synchronized on each session
Background reconciliation runs every 24 hours; OIDC session refresh checks run every 15 minutes
Inactive or deprovisioned users are decommissioned locally (including via inbound SCIM 2.0)

Configuration lives under scim_config in config.json. See the User Provisioning docs for provider-specific setup guides.

📋 Audit logs

Audit logs in Bifrost record administrative activity who changed what, when, and which resource was affected. They do not use a log_level / capture / export_to block.

Real configuration shape:

{
  "audit_logs": {
    "disabled": false,
    "hmac_key": "env.AUDIT_HMAC_KEY",
    "retention_days": 365,
    "object_storage": {
      "type": "s3",
      "bucket": "acme-audit-archive",
      "prefix": "acme-prod",
      "compress": true,
      "region": "us-east-1",
      "access_key_id": "env.AUDIT_S3_KEY",
      "secret_access_key": "env.AUDIT_S3_SECRET"
    }
  }
}

Key features:

Signed events — configure an HMAC key for verification
Dashboard review — filter by search text, action, outcome, and date range
Export — JSON, JSON Lines, or Syslog (requires AuditLogs:Download permission)
Retention — retention_days controls database retention
Object storage archival — optional mirror to S3/GCS for long-term compliance retention

View audit entries at Governance → Audit Logs in the dashboard.

✅ Implementation best practices

1. Rely on deny-by-default

Do not look for a "policy": "default_deny" setting. It does not exist. Instead:

Create virtual keys with explicit mcp_configs for each team or environment
Set client-level tools_to_execute to the minimum needed
Leave production database tools off keys used for local development

2. Keep human-in-the-loop as the default

Only enable Agent Mode auto-execution for tools you have explicitly reviewed. The default flow — chat → review → /v1/mcp/tool/execute — is your strongest safety net.

3. Separate runtime access from admin access

Runtime (what agents can do): virtual keys + mcp_configs + request headers
Administration (who can change configs): RBAC + SSO

4. Use environment-scoped virtual keys

{
  "name": "production-readonly",
  "mcp_configs": [
    { "mcp_client_name": "production_database", "tools_to_execute": ["query"] }
  ]
}

{
  "name": "staging-full",
  "mcp_configs": [
    { "mcp_client_name": "staging_database", "tools_to_execute": ["*"] }
  ]
}

5. Configure audit logging early

Enable HMAC signing, set retention_days comfortably above your archival window, and optionally mirror to object storage for compliance.

6. Perform regular access reviews

Schedule quarterly reviews to answer:

Which virtual keys grant access to production MCP clients?
Who has Admin or Developer RBAC roles in Enterprise?
Are there overprivileged virtual keys or dormant SSO accounts?

Use the dashboard and /api/roles endpoints, there is no bifrost audit CLI command. The @maximhq/bifrost-cli package is an interactive launcher for coding agents (Claude Code, Codex CLI, Gemini CLI, Opencode), not an audit tool.

🖋️ Conclusion

With Bifrost, you can configure your company's MCP server much more securely. This ready-made solution will save you not only money but also time, which can be spent on product development.

🔗 Resources:

Bifrost GitHub: https://github.com/maximhq/bifrost
Bifrost Docs: https://docs.getbifrost.ai
Bifrost CLI: npx -y @maximhq/bifrost-cli

Thanks for reading this article! ❤️

I'd love to hear your thoughts on this mode in the comments!