Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Overview

FrameX logo

FrameX is a plugin-first Python framework for teams that need service decomposition, multi-team parallel development, private implementation boundaries, and one consistent service surface across local plugins and upstream APIs.

It is designed for services that are growing beyond a single cohesive code path and need clearer capability boundaries without forcing teams to build a custom platform first.

Core capabilities:

  • plugin registration and discovery
  • FastAPI route generation from plugin methods
  • internal plugin API calls
  • optional Ray Serve execution
  • built-in example and proxy plugins
  • configuration from environment variables, TOML, and pyproject.toml

FrameX architecture

What Problem It Solves

FrameX is most useful when multiple teams need to ship capabilities in parallel, call each other through stable service interfaces, and keep implementation details private so each team can work without understanding or depending on other teams’ codebases.

Use it when you need to:

  • build service capabilities as plug-and-play modules
  • let multiple engineers or teams ship in parallel with clearer ownership boundaries
  • split a growing service into independently evolving capability units
  • call other teams’ capabilities without depending on their codebases
  • expose local plugins and upstream APIs behind one consistent service surface
  • integrate third-party or internal HTTP services with minimal client-side changes
  • start with simple local execution and scale to Ray when needed
  • keep the system extensible as capabilities, teams, and traffic grow

Why FrameX Instead Of Plain FastAPI

Plain FastAPI is a good choice for a single cohesive application. FrameX is better when the real problem is not route handling, but service decomposition, team boundaries, and cross-service integration.

Compared with plain FastAPI, FrameX gives you:

  • plugin boundaries for clearer ownership between capabilities and teams
  • a better development model for plug-and-play modules and parallel delivery
  • one consistent surface for local capabilities and upstream HTTP services
  • internal callable APIs in addition to normal HTTP routes
  • explicit dependency declarations between capabilities
  • the ability to start locally and move to Ray-backed execution without rewriting plugin code

If you only need a small application with a stable route surface and one codebase, plain FastAPI is usually simpler.