⚡ Zaltech

A full-stack framework for building AI-native, cross-provider applications that run across ChatGPT, OpenAI, Gemini, Claude, and any MCP-compatible platforms. Designed to standardize how you build tools, UI widgets, and integrations on top of the Model Context Protocol (MCP).

🚀 Coming Soon (2026): Zaltech framework will be publicly available in 2026.

Web Apps had React → AI Apps have Zaltech. ❤️‍🔥

Why Zaltech Exists

Today, building real AI applications means dealing with:

Fragmented provider SDKs
Custom MCP servers per project
One-off UI bridges for every platform
No standard way to ship interactive AI apps
Rewriting the same transport, auth, and rendering logic

Zaltech unifies all of that into one consistent, standards-aligned developer surface.

Core Features

| Feature | Description | |-----------------------------|-------------| | MCP-First Architecture | Native implementation of MCP tools, resources, prompts, and structured output using FastMCP from the official Python SDK. | | Cross-Provider Runtime | Run the same app across multiple hosts; OpenAI is fully supported today, with Gemini, Claude, and others following as MCP support matures. | | Native AI UI System | Host-native, responsive UI components and interactive widgets rendered via MCP resources using React, reusable across chat clients, dashboards, and native or hybrid applications. | | Feature-Based Architecture | Each capability is a vertical slice (tool + logic + UI), giving clean, domain-driven boundaries and easy reuse. | | Streaming-First Transport | Built on HTTP streaming and SSE for low-latency responses, stateless scaling, and JSON output by default. | | Authentication Out of the Box | OAuth-ready, token-based auth with secure MCP auth flows and minimal configuration. | | Observability Built In | Batteries-included observability stack with structured logs, request tracing, and dashboards pre-wired via OpenTelemetry, Grafana, Loki, and Prometheus so logs, metrics, and traces work out of the box. | | MCP Inspector (First-Class) | Visual inspection and testing of tools, prompts, resources, logs, and execution flow using MCP Inspector. | | Local Visual UI Testing | Storybook-style sandbox for building and iterating on widgets without live LLM calls. | | Agentic Checkout | Built-in support for Agentic Checkout with REST endpoints, webhooks, and delegated payments for end-to-end checkout flows inside ChatGPT. | | Delegated Payment | Built-in support for Delegated Payment enabling secure payment token delegation to PSPs and merchants with single-use, constrained tokens for PCI-compliant transactions. | | State Management | Built-in patterns for managing business state on server, ephemeral UI state in widgets via window.openai.widgetState, and cross-session state in your backend storage. | | One-Command DX & Deploy | One command to run locally and one to deploy—no manual infrastructure orchestration. |

For ChatGPT App Developers

If you're building ChatGPT Native Apps today, you typically start by wiring together the OpenAI Apps SDK and OpenAI Apps UI SDK, then you still have to figure out project structure, streaming, state, auth, payments, deployment, tooling, and much more.

Zaltech is an easy starter framework built directly on top of both SDKs and more, delivered pre-wired with structure, observability, visual UI sandbox, and much more, so you can ship immediately instead of assembling infrastructure.

Tech Stack

Zaltech is an opinionated full-stack framework with a Python backend and TypeScript frontend, providing a modern, type-safe developer experience and leveraging industry-standard tools to deliver a production-ready foundation.

Core Framework

FastAPI – High-performance Python web framework
Pydantic – Data validation & settings management

Frontend & UI

React + TypeScript – Modern, type-safe UI layer
Tailwind CSS – Utility-first styling
Vite – Blazing-fast build tool & dev server
OpenAI Apps UI SDK – Official ChatGPT-native components (For OpenAI Apps)

Developer Experience

Storybook – Isolated UI sandbox (no LLM calls required)
Vitest – Fast unit & integration testing for React components
Pytest – Python testing framework with fixtures & plugins
MCP Inspector – Visual debugging for tools, prompts, resources & logs

Observability

OpenTelemetry – Traces, metrics & logs instrumentation
Prometheus + Grafana – Metrics & dashboards
Loki + Promtail – Log aggregation & querying

Infrastructure & Deployment

Docker – Containerized services
Docker Compose – One-command local & production-ready stack

Protocol Layer

MCP Python SDK – Official Model Context Protocol implementation

Architecture

Zaltech is feature-first across the entire stack, with each feature implemented as a complete vertical slice spanning three layers.

Three-Layer Feature Architecture

Each feature is organized as a self-contained vertical slice:

feature_name/
├── mcp/src/features/{feature}/     # MCP Layer
│   ├── tool.py                     # MCP tool definition & handler
│   ├── resource.py                 # Widget resource definitions
│   └── models.py                   # Pydantic data models
│
├── app/src/features/{feature}/      # App Layer
│   ├── generator.py                 # Core business logic
│   └── extractor.py                 # Trigger/keyword extraction
│
└── ui/src/features/{feature}/       # UI Layer
    └── React component              # Embedded widget for AI hosts

Layer Responsibilities

MCP Layer (mcp/src/features/)

Defines MCP tools, schemas, and UI resources
Handles tool registration and routing
Manages authentication and authorization per tool
Exposes widget resources via MCP resource endpoints

App Layer (app/src/features/)

Implements business logic and domain rules
Handles provider routing and AI API calls
Processes data extraction and transformation
Manages state and orchestration

UI Layer (ui/src/features/)

React components rendered as embedded widgets
Interactive UI for AI host platforms
State management via widget state APIs
Responsive layouts using Apps SDK UI primitives

AI Providers Support

| Rank | AI Provider | MCP Ready | Zaltech UI Runtime | Status | Notes | |------|--------------------------------|-----------|----------------------|--------------------------|-------------------------------------------------------------------------| | 1 | ChatGPT (OpenAI) | ✅ Ready | ✅ Ready | Ready | UI runtime ready; public release after OpenAI marketplace opens. | | 2 | Google Gemini | ✅ Ready | ⏳ Pending | Planned | Enabled as soon as Gemini exposes an MCP-based app/UI runtime. | | 3 | Anthropic Claude | ✅ Ready | ⏳ Pending | Planned | Enabled as soon as Claude exposes an MCP-based app/UI runtime. | | 4 | LLaMA (Meta) | ✅ Ready | ⏳ Pending | Planned | MCP-compatible; UI runtime support needed from the host. | | 5 | Mistral AI | ✅ Ready | ⏳ Pending | Planned | MCP-compatible; runtime support required. | | 6 | Grok (X) | ✅ Ready | ⏳ Pending | Planned | Enabled as soon as Grok exposes an MCP-based app/runtime surface. | | 7 | Other MCP Hosts | ✅ Ready | 🟡 Host-dependent | Ongoing | Automatically supported for any MCP host that exposes a UI/runtime. |

Community

💬 Join the Community: Join our Discord to get early access, and stay updated.

Vision

Make building AI-native applications as standard as building web apps.

Built by Mahmoud Zalt at Sista AI.

MCP Servers