🌐 Official Website: https://makerai.cimamaker.com 📖 Manual: https://www.gustavoenriquez.com/book-makerai — available in English and Spanish

GitHub Stars GitHub Issues License Telegram Delphi Supported Versions Free Pascal

Free Pascal / Lazarus port available — Full port of MakerAI Suite for FPC 3.2+ (12 LLM drivers, RAG, Agents, MCP, Embeddings). See the fpc branch.

Most AI libraries for Delphi stop at wrapping REST calls. MakerAI is different.

Yes, MakerAI includes native, provider-specific components that give you direct, full-fidelity access to each provider's API — every model parameter, every response field, every streaming event, exactly as the provider defines it.

But on top of that, MakerAI is a complete AI application ecosystem that lets you build production-grade intelligent systems entirely in Delphi:

• RAG pipelines (vector and graph-based) with SQL-like query languages (VQL / GQL)
• Autonomous Agents with graph orchestration, checkpoints, and human-in-the-loop approval
• MCP Servers and Clients — expose or consume tools using the Model Context Protocol
• Native ChatTools — bridge AI reasoning with deterministic real-world capabilities (PDF, Vision, Speech, Web Search, Shell, Computer Use)
• FMX Visual Components — drop-in UI for multimodal chat interfaces
• Universal Connector — switch providers at runtime without changing your application code

Whether you need a simple one-provider integration or a multi-agent, multi-provider, retrieval-augmented production system, MakerAI covers the full stack — natively in Delphi.

v3.4 is fully tested and compatible with Delphi 13.1 Florence (CompilerVersion 37.1), in addition to the existing range from Delphi 10.4 Sydney through Delphi 13 Florence.

The biggest infrastructure change in v3.4: TAiChatConnection no longer force-loads all providers at startup. Each driver now self-registers only when explicitly imported, eliminating unnecessary initialization overhead:

// Load only what you need
uses uMakerAi.Chat.AiConnection, uMakerAi.Chat.OpenAi, uMakerAi.Chat.Claude;
// Load all drivers at once (legacy behavior)
uses uMakerAi.Chat.Initializations;

New universal connector for real-time speech-to-text via WebSocket:

• TAiRealtimeConnection — provider-agnostic STT connector; switch providers via DriverName
• TAiOpenAiRealtimeSTT — full OpenAI Realtime API implementation (24 kHz PCM16, VAD modes, streaming transcription)
• Pure-Pascal WebSocket client with native TLS via Windows SChannel — no extra DLLs required
• Thread-safe PCM16 resampler; supports push-based audio streaming from any source

New ChatMode value for automatic two-pass routing:

• Pass 1 — classifies the user intent and rewrites the prompt for the target capability (image generation, speech synthesis, web search, etc.)
• Pass 2 — dispatches to the appropriate bridge or tool based on classification
• Works with all existing ChatTools (IAiImageTool, IAiSpeechTool, IAiWebSearchTool, etc.)

• TAiAgentManager.Run declared virtual — proper subclassing now supported
• jmAll join node fix — FJoinInputs cleared after each execution; eliminates premature firing on retries and loops
• TChatInput.EnterAsSend — new property (default False): Enter sends the prompt, Shift+Enter / Ctrl+Enter inserts a line break
• TChatBubble — eliminated spurious vertical scrollbar (ShowScrollBars := False)

• Claude Opus 4.7 Adaptive Thinking — temperature, top_p, top_k and the thinking block are now correctly omitted for claude-opus-4-7 models. Anthropic manages sampling internally for these models; sending these parameters caused HTTP 400 errors.
• RegisterDefaultParams — Max_Tokens key — corrected in 10 drivers (Claude, Gemini, Mistral, Groq, DeepSeek, Grok, Kimi, LMStudio, GenericLLM, Ollama). The wrong key MaxTokens was never resolved by RTTI to the Max_tokens property, causing Max_Tokens to be silently ignored when set via RegisterDefaultParams.
• ApplyParamsToChat — locale-independent float parsing — TryStrToFloat now tries invariant format (dot decimal) first, then falls back to the system locale. Both Temperature=0.7 and Temperature=0,7 are valid regardless of regional settings.

• MCP concurrent tool calls — race condition (uMakerAi.MCPClient.Core.pas): When a model responded with two or more tools from the same MCP server in a single turn, ParseChat launched all tool calls as parallel TTasks. Since TMCPClientStdIo shares a single process/pipe per instance (no synchronization), concurrent calls corrupted the JSON-RPC communication, causing intermittent failures. Fixed by adding FCallLock: TCriticalSection to TMCPClientCustom — calls to the same server are now serialized while calls to different servers still run in parallel.

• EAggregateException on tool errors — Claude driver (uMakerAi.Chat.Claude.pas): The local _CreateTask procedure in TAiClaudeChat.ParseChat lacked the try/except present in the base class. Any exception raised inside a tool task (MCP timeout, network error, etc.) escaped unhandled, causing TTask.WaitForAll to wrap it in an EAggregateException and crash the application. Fixed to match base class behavior: exceptions are caught, reported via OnError, and the tool receives an error response so the conversation can continue.

┌──────────────────────────────────────────────────────────────────┐
│ Your Delphi Application │
└────┬──────────────────┬─────────────────┬────────────────────────┘
 │ │ │
┌────▼────┐ ┌─────────▼──────────┐ ┌──▼────────────────────────┐
│ ChatUI │ │ Agents │ │ Design-Time │
│ FMX │ │ TAIAgentManager │ │ Property Editors │
│ Visual │ │ TAIBlackboard │ │ Object Inspector support │
│ Comps │ │ Checkpoint/Approve │ └───────────────────────────┘
└────┬────┘ └─────────┬──────────┘
 │ │
┌────▼──────────────────▼──────────────────────────────────────────┐
│ TAiChatConnection — Universal Connector │
│ Switch provider at runtime via DriverName property │
└──────────────────────────────┬───────────────────────────────────┘
 │
┌──────────────────────────────▼───────────────────────────────────┐
│ Native Provider Drivers (direct API access, full fidelity) │
│ OpenAI · Claude · Gemini · Grok · Mistral · DeepSeek · Kimi │
│ Groq · Cohere · Ollama · LM Studio · GenericLLM │
└──────────────────────────────┬───────────────────────────────────┘
 │
 ┌─────────────────────────┼────────────────────────┐
 │ │ │
┌────▼────────┐ ┌────────────▼────────┐ ┌───────────▼─────────┐
│ ChatTools │ │ RAG │ │ MCP │
│ PDF/Vision │ │ Vector (VQL) │ │ Server (HTTP/SSE │
│ Speech/STT │ │ Graph (GQL) │ │ StdIO/Direct) │
│ Web Search │ │ PostgreSQL/SQLite │ │ Client │
│ Shell │ │ HNSW · BM25 · RRF │ │ TAiFunctions bridge│
│ ComputerUse│ │ Rerank · Documents │ └─────────────────────┘
└─────────────┘ └─────────────────────┘

MakerAI gives you two ways to work with each provider, which you can mix freely:

Full, provider-specific access to every API feature. Use when you need complete control:

Provider-agnostic code. Switch models or providers by changing one property:

AiConn.DriverName := 'OpenAI';
AiConn.Model := 'gpt-5.2';
AiConn.ApiKey := '@OPENAI_API_KEY'; // resolved from environment variable
// Switch to Gemini without changing anything else
AiConn.DriverName := 'Gemini';
AiConn.Model := 'gemini-3.0-flash';
AiConn.ApiKey := '@GEMINI_API_KEY';

Legend: ✅ Native | ⚠️ Tool-Assisted bridge | ❌ Not Supported

Two complementary retrieval engines with their own query languages:

Vector RAG — semantic and hybrid search over document embeddings:

• HNSW index for approximate nearest-neighbor search
• BM25 lexical index for keyword matching
• Hybrid search with RRF (Reciprocal Rank Fusion) or weighted fusion
• Reranking and Lost-in-the-Middle reordering for LLM context
• VQL (Vector Query Language) — SQL-like DSL for complex retrieval queries:

  MATCH documents SEARCH 'machine learning'
  USING HYBRID WEIGHTS(semantic: 0.7, lexical: 0.3) FUSION RRF
  WHERE category = 'tech' AND date > '2025年01月01日'
  RERANK 'neural networks' WITH REGENERATE
  LIMIT 10

• Drivers: PostgreSQL/pgvector, SQLite, in-memory

Graph RAG — knowledge graph with semantic search over entities and relationships:

• Nodes and edges with embeddings and metadata
• MakerGQL — Graph Query Language based on ISO/IEC 39075:2024 (GQL standard):

  MATCH (p:Person)-[r:WORKS_AT]->(c:Company)
  WHERE c.city = 'Madrid' DEPTH 2
  RETURN p, r, c

• Dijkstra shortest path, centrality analysis, hub detection
• Export to GraphViz DOT, GraphML (Gephi), native JSON format
• Document lifecycle management (ingest → chunk → embed → link)

Graph-based multi-agent workflows with full thread safety:

• TAIAgentManager — executes directed graphs of AI nodes via thread pool
• TAIAgentsNode — single execution unit; runs an LLM call, a tool, or custom logic
• TAIBlackboard — thread-safe shared state dictionary between all nodes
• Link modes: lmFanout (parallel broadcast), lmConditional (routing), lmExpression (binding), lmManual
• Join modes: jmAny (first arrival wins), jmAll (wait for all inputs)
• Durable execution: IAiCheckpointer persists full agent state between process restarts; built-in implementations: TAiFileCheckpointer (JSON files) and TAiDatabaseCheckpointer (FireDAC — SQLite, PostgreSQL, Firebird, etc.)
• Human-in-the-loop: Node.Suspend(Reason, Context) pauses a node and saves the checkpoint; TAiWaitApprovalTool provides a drop-in approval tool; resume with ResumeThread(ThreadID, NextNode, HumanInput)
• Supports any LLM provider via TAiChatConnection

Full implementation of the MCP standard for both consuming and exposing tools:

MCP Server — expose Delphi functions as MCP tools, callable by any MCP client (Claude Desktop, AI agents, etc.):

• Transports: HTTP, SSE (Server-Sent Events), StdIO, Direct (in-process)
• Bridge TAiFunctions → IAiMCPTool — any existing TAiFunctions component becomes an MCP server instantly
• API Key authentication, CORS configuration
• TAiMCPResponseBuilder for structured responses (text + files + media)
• RTTI-based automatic JSON Schema generation from parameter classes

MCP Client — consume any external MCP server from your Delphi app:

• Connect to Claude Desktop tools, filesystem servers, database tools, etc.
• Integrated into TAiFunctions component alongside native function definitions

ChatTools bridge the gap between AI reasoning and real-world operations. They activate automatically based on gap analysis between SessionCaps and ModelCaps:

Tools follow a common pattern: SetContext(AiChat) + Execute*(). They can run standalone, as function-call bridges, or as automatic capability bridges.

Introduced in v3.3 and refined in v3.4, the TAiCapabilities system replaces all manual feature flags with two declarative sets:

• ModelCaps — what the model natively supports (e.g., [cap_Image, cap_Reasoning])
• SessionCaps — what the session needs
• Gap = SessionCaps − ModelCaps — any missing capability activates an automatic ChatTool bridge; for example, a text-only model with cap_GenImage in SessionCaps automatically routes image generation requests through a DALL-E or Gemini bridge

// Default capabilities for all models of a provider
TAiChatFactory.Instance.RegisterUserParam('MyProvider', 'ModelCaps', '[cap_Image, cap_Pdf]');
TAiChatFactory.Instance.RegisterUserParam('MyProvider', 'SessionCaps', '[cap_Image, cap_Pdf, cap_GenImage]');
// Per-model override (e.g., a reasoning model)
TAiChatFactory.Instance.RegisterUserParam('MyProvider', 'my-model', 'ModelCaps', '[cap_Image, cap_Reasoning]');
TAiChatFactory.Instance.RegisterUserParam('MyProvider', 'my-model', 'ThinkingLevel', 'tlMedium');

Available capabilities: cap_Image, cap_Audio, cap_Video, cap_Pdf, cap_Reasoning, cap_WebSearch, cap_GenImage, cap_GenVideo, cap_TTS, cap_STT, cap_ComputerUse

ThinkingLevel controls reasoning depth: tlLow, tlMedium, tlHigh.

Two generations of FireMonkey components for building multimodal chat UIs:

Next-generation (v3.4) — Skia-native, virtualized, zero FMX child controls:

• TAIChatView — single-canvas virtualized conversation renderer; only visible messages are painted; supports multi-message text selection, dark/light theme, context menu, long-press (mobile), copy-button feedback with timer, and a scrollbar that doesn't interfere with content
• TAIChatInput — fully Skia-painted input bar with custom dropdown overlay (no TPopupMenu required), voice-mode indicator, file attachment chips, and TAIVoiceMonitor integration; layout adapts from 1 to N attachment chips automatically

Classic components — FMX-layout-based, simpler to subclass:

• TChatList — scrollable message container with Markdown rendering, code blocks, copy buttons
• TChatBubble — individual message bubble (user / assistant / tool)
• TChatInput — text input bar with voice recording, file attachment, and send button

Both sets are compatible with all providers and work with streaming responses.

Full Delphi IDE support via the MakerAiDsg.dpk design-time package:

• DriverName property shows a dropdown of all registered providers in the Object Inspector
• Model property lists all models for the selected provider
• MCP Client configuration editor with transport type selection
• Embedding connection editor
• Version/About dialog

git clone https://github.com/gustavoeenriquez/MakerAi.git

Before compiling any package, add all of these to Tools > Options > Language > Delphi > Library:

Source/Agents
Source/Chat
Source/ChatUI
Source/Core
Source/Design
Source/Embeddings
Source/MCPClient
Source/MCPServer
Source/Packages
Source/RAG
Source/Realtime
Source/Resources
Source/Tools
Source/Utils
Source/WebSocket

Compile and install in this exact order:

1. Source/Packages/MakerAI.dpk — Runtime core (~100 units)
2. Source/Packages/MakerAi.RAG.Drivers.dpk — PostgreSQL/pgvector connector
3. Source/Packages/MakerAi.UI.dpk — FMX visual components
4. Source/Packages/MakerAiDsg.dpk — Design-time editors (requires VCL + DesignIDE)

Open Source/Packages/MakerAiGrp.groupproj to compile all packages at once.

API keys are resolved from environment variables using the @VAR_NAME convention:

AiConn.ApiKey := '@OPENAI_API_KEY'; // reads OPENAI_API_KEY from environment
AiConn.ApiKey := '@CLAUDE_API_KEY'; // reads CLAUDE_API_KEY
AiConn.ApiKey := '@GEMINI_API_KEY'; // reads GEMINI_API_KEY
AiConn.ApiKey := 'sk-...'; // or set a literal key directly

Open Demos/DemosVersion31.groupproj to access all demos.

• Tested with Delphi 13.1 Florence
• Selective driver registration — each driver self-registers only when imported
• New: TAIChatView — next-generation Skia-native virtualized chat renderer (single canvas, no FMX child controls, multi-message text selection, dark/light theme, mobile long-press)
• New: TAIChatInput — fully Skia-painted input bar with custom dropdown overlay, attachment chips, voice indicator (no TPopupMenu / no FMX buttons)
• New: TAiRealtimeConnection + TAiOpenAiRealtimeSTT — real-time STT via WebSocket (24 kHz PCM16, VAD, streaming transcription; pure-Pascal TLS via Windows SChannel)
• New: cmSmartDispatch chat mode — two-pass intelligent routing
• Models: claude-opus-4-7, gpt-5.4/5.5, gemini-3.1-pro, grok-4-fast, kimi-k2, groq llama-4
• Fix: Claude Opus 4.7 Adaptive Thinking — HTTP 400 eliminated (temperature/top_p/top_k + thinking block now omitted for claude-opus-4-7)
• Fix: AV on async abort — nil guard in TAiChatConnection.OnInternalReceiveDataEnd
• Fix: TStringStream leak in async HTTP requests — FCurrentPostStream lifetime now correctly tied to request completion
• Fix: RegisterDefaultParams Max_Tokens key corrected in 10 drivers
• Fix: ApplyParamsToChat TryStrToFloat now locale-independent
• Fix: Agent jmAll join node premature firing on retries
• Fix: TChatBubble spurious vertical scrollbar eliminated
• New: TChatInput.EnterAsSend property
• New: TAiDatabaseCheckpointer — FireDAC-based checkpoint persistence; works with SQLite, PostgreSQL, Firebird, MySQL, SQL Server, and any other FireDAC driver
• Fix: D11 Alexandria compatibility — TInterlocked.Exchange(Boolean) (D12-only) replaced with Integer-based atomic; AddStream(AShareOwnership) boundary corrected to CompilerVersion >= 36; THashSet<T> boundary corrected to CompilerVersion >= 36

• New TAiCapabilities system (ModelCaps / SessionCaps / ThinkingLevel)
• Models updated: OpenAI gpt-5.2, Claude 4.6, Gemini 3.0, Grok 4, Mistral Magistral, DeepSeek-reasoner, Kimi k2.5
• Agents: durable execution (checkpoints), human-in-the-loop approval tool
• RAG: Graph Document management (uMakerAi.RAG.Graph.Documents)
• Fix: reasoning_content preserved in multi-turn tool calls (DeepSeek, Kimi, Groq)
• New: TAiEmbeddingsConnection, TAiAudioPushStream
• New demos: DocumentManager, ChatWebList

• Native ChatTools framework (IAiPdfTool, IAiVisionTool, IAiSpeechTool, etc.)
• Unified deterministic tool orchestration and capability bridges

• GPT-5.1, Gemini 3.0, Claude 4.5 initial support
• FMX multimodal UI components
• RAG Rerank + Graph RAG engine
• MCP Server framework (SSE, StdIO, HTTP)

• Major architecture redesign
• Visual FMX chat components
• Graph-based vector database
• Delphi 10.4–13 compatible (limited: 10.4 Sydney; full support: 11 Alexandria+)

• MCP Client/Server (Model Context Protocol)
• Agent graph orchestration
• Linux/POSIX full support

• Website: https://makerai.cimamaker.com
• Manual (EN/ES): https://www.gustavoenriquez.com/book-makerai
• Telegram (Spanish): https://t.me/MakerAi_Suite_Delphi
• Telegram (English): https://t.me/MakerAi_Delphi_Suite_English
• Email: gustavoeenriquez@gmail.com
• GitHub Issues: https://github.com/gustavoeenriquez/MakerAi/issues

MIT License — see LICENSE.txt for details.

Copyright © 2024–2026 Gustavo Enríquez — CimaMaker