MakerAI Suite v3.8 — The AI Ecosystem for Delphi
🌐 Official Website: https://makerai.cimamaker.com 📖 Manual: https://www.gustavoenriquez.com/book-makerai — available in English and Spanish
接入你的智能体
從發布者安裝。不是 PlugMCP 端點。
遠端 URL 還是本機指令? 兩種安裝方式的差異
來自發布者
🌐 Official Website: https://makerai.cimamaker.com 📖 Manual: https://www.gustavoenriquez.com/book-makerai — available in English and Spanish
The AI Operating System for Delphi. 100% native framework with RAG 2.0, autonomous agents, MCP protocol, and universal LLM connector. Supports OpenAI, Claude, Gemini, Ollama, and more. Delphi 10.4+ (limited), full support from Delphi 12 Athens.
Free Pascal / Lazarus port available — Full port of MakerAI Suite for FPC 3.2+ (12 LLM drivers, RAG, Agents, MCP, Embeddings). See the
fpcbranch.
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:
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.
TAiOpenAiLiveChat (gpt-live-1, DriverName OpenAiLive) listens while it speaks: you can interrupt it, and it hands the heavy thinking to another model — a Responses model run by OpenAI (web search, your TAiFunctions and MCP tools executed locally) or any TAiChatConnection through DelegateChat (Claude, Ollama, an agent graph). Conversation turns are rebuilt from the session timeline, so overlapping speech no longer splits answers. Demo 092-GPTLiveVoice: microphone, speaker, local functions, RAG over MCP with a read-only guardrail, anti-echo speaker mode and a quick guide. Tested live.
Ollama 0.35+ serves the Jev contract at /v1/systemone with local decision models — nimble, tev1 and Cloudflare's clef/clef-flash. TAiJev only needs Url := 'http://localhost:11434/v1/'; the eight Jev adapters gained Url, TAiJev.Ask takes images for Clef (PNG/JPEG/WebP), and the TypeSafe price is no longer charged on other servers. Tested with nimble (routing, prompt guard, batch labeling) and clef 27B on images.
An MCP server leaked every tool schema on each tools/list (it grew forever in production), the MCP client leaked the tools/list response on each Initialize, and TAiRealtimeFactory never freed its dictionary.
TAiOpenAiAudio / TAiOpenAiSpeechTool use gpt-transcribe and gpt-4o-mini-tts (OpenAI shuts down whisper-1 on 2027-02-26 and tts-1 on 2027-01-06). gpt-transcribe returns JSON only — srt/vtt/timestamps are reported in TTranscriptionResult.Warning; set tmWhisper1 to keep them until the shutdown.IAiMCPTool.GetInputSchema returns a new object owned by the caller (what the built-in tools already did). A custom tool that returned a cached field must return a copy.Max_Tokens is now sent as max_output_tokens (it was silently ignored), so a low limit can cut answers that used to be complete.Released 2026-09-29. Six items change existing behaviour; they are marked ⚠️ below — two of them
(TLS certificate checks on POSIX and the IAiMemoryStorage signature) can require code changes.
TAiJev (Source/Tools/uMakerAi.Jev.pas) wraps Jev, TypeSafe AI's "System One" model.
Jev does not generate text: it answers typed questions — Choice, Score, Noul (yes/no) —
with calibrated probabilities and a confidence value your code can threshold. It is meant for
the fast, cheap decisions that today cost a full LLM round-trip: routing a query to the right
specialised agent, deciding whether that agent needs its RAG variant, classifying, gating.
Several questions travel in one request (~700 input tokens at US$0.042 per million). Questions
are validated locally, 429/529 are retried with backoff, and the model is pinned to
jev-1.13.0 so thresholds stay valid. Demo: 084-JevRouter.
For agent graphs, TAiJevRouterTool (Source/Agents/uMakerAi.Agents.Tools.JevRouter.pas) is a
node tool that writes the chosen route to Blackboard['next_route'], so an existing
lmConditional link follows it — no engine change. Low confidence or a failing API falls back
to NextNo instead of breaking the graph, and yes/no flags asked in the same call land in the
blackboard for lmExpression or an OnRoute handler. Twenty-one new regression cases run all
of it offline against a fake transport.
Two more hand-offs make Jev a drop-in for decisions the framework already takes:
SmartDispatch without the classification LLM call. ChatTools.DispatchClassifier (new,
provider-neutral) receives the tags whose tools are assigned; TAiJevDispatchClassifier answers
with Jev. Tool requests skip one LLM round-trip, and CHAT replies are now generated with the
conversation history (the LLM pass answered in an isolated two-message context). Unsure or
failing → the usual LLM pass. 15/15 on Spanish and English requests.
Semantic guardrails. TAiGuardrails.Classifier (new) judges the tool calls the allow/block
lists let through; TAiJevGuardrailClassifier blocks when P(risk) ≥ 0.5. Lists still catch the
enumerable (rm -rf) for free; Jev catches what no list anticipates — an e-mail carrying a
password to an outside address, a transfer to an unknown account. Safe calls scored ≤ 0.17 and
harmful ones ≥ 0.88 across 13 calibration cases. Fails closed by default. Optional permission
categories (read, write, financial, system, …) are judged in the same call: block whole
categories, audit each call via OnCategorized, and describe domain-named tools with
ToolDescriptions (20/20 on 20 calibration calls).
Input guardrail. ChatTools.PromptGuard (new) checks the user's message before it reaches
the LLM, right after the existing regex sanitizer. TAiJevPromptGuard asks in one call about
prompt injection, credentials in the message, harmful requests and — given a Scope — off-topic
questions. On nine test messages the regex caught 1 of 6 problematic ones; Jev caught all 6 and
let the greeting and the legitimate questions through. A blocked message never touches the network.
Demo: 085-JevDispatchGuard.
And two more for quality and retrieval:
TAiEvalRunner.Scorer (new) answers ExpectScore('criterion', 0.7)
with the probability that the output meets the criterion — faster and cheaper than an LLM
judge, and the bar is set in code. TAiJevEvalScorer: passing answers ≥ 0.97, failing ≤ 0.02
on 10 calibration pairs.TAiRAGVector.Reranker (new) replaces the cosine second stage
of VQL RERANK: TAiJevRAGReranker scores each passage for usable evidence and drops
passages that try to instruct the model (prompt injection). No embeddings are recomputed;
if the reranker fails, the search falls back to cosine. Demo: 086-JevEvalsRag.TAiJevBatchLabeler runs the same questions over many rows in parallel and
returns labels, confidence, top-3 suggestions, total cost and the rows worth a human look; a
failing row never stops the batch. Validated by reproducing the prototype: 126 accounting
entries against 225 chart-of-accounts codes in 4.2 s for US$0.05 — 92.9% overall and 100% on
the 61% it would book automatically (confidence ≥ 0.8). Demo: 087-JevBatchLabeling.TAiJevModelRouter sends each request to the cheapest model that can handle
it. Jev describes the request (task, difficulty, sensitivity); readable rules in code pick the
tier. Switching provider on a TAiChatConnection used to drop the conversation — the router
migrates the text history, so a chat can start on Groq and escalate to Claude and still
remember the first turn. Live, with Groq → DeepSeek → Claude Sonnet → Opus: 7 of 8 answers
judged useful, the trivial ones in under a second. Demo: 088-JevModelRouter.TAiJev and all eight adapters expose Usage (requests,
input/output tokens, cost in USD) and an OnUsage event fired once per operation — one guard
check, one rerank, one batch — on the thread that ran it, so a server can charge the right
customer. The parallel reranker reports a single total after joining its calls. Previously only
the batch labeler exposed tokens; the other adapters received them and dropped them.Also fixed: lmExpression parsed numbers with the regional settings only, so on a Windows
using a decimal comma '10.25' > 9.5 was compared as text and returned False. It now falls
back to a decimal point.
TAiLinuxExecutor (Source/Tools/uMakerAi.Tools.ComputerUse.Linux.pas) drives X11 through
xdotool and captures with scrot, covering the 19 canonical actions with the same
public interface as the Windows and macOS executors. The framework itself needed no change:
TAiComputerUseTool only ever used the RTL and delegates everything to
OnExecuteAction / OnRequestScreenshot, so it cross-compiled to Linux64 untouched — what
was missing was only the executor. Runtime-tested on Xvfb with gpt-6-astra and
claude-opus-4-8, driving both a text editor and Chrome. Demo: 083-ComputerUseLinux.
A headless process (a broker on a VPS) can now claim a computer_call and forward it to
whoever actually owns a screen. The contract already existed in the base class and in Claude
— fill ToolCall.Response from OnCallToolFunction and the driver does not execute
locally — but OpenAI ignored it and Gemini never even fired the event. Both now honour
it. For OpenAI the delegation is atomic over the batch: gpt-6-astra sends an array of
actions that admits a single computer_call_output, so splitting it between a local and a
remote executor would leave the final screenshot ownerless. Demo: 082-ComputerUsePassthru.
TOpenSSLTransport used to run with SSL_VERIFY_NONE — it accepted any certificate,
from anyone, and that is the transport the Realtime module uses on Linux and macOS. It now
verifies the chain against the system CA store and the hostname (SSL_set1_host;
SSL_VERIFY_PEER alone validates the chain but not that the certificate was issued for the
host you dialed). Verified against badssl.com, 7/7, including the wrong.host case.
Breaking: pointing Realtime at an endpoint with a self-signed certificate (a local LM Studio, an internal proxy) now fails until you set
InsecureSkipVerify := True.
TAiGeminiChat.DoCallFunction had its inherited commented out and answered
'Command <name> not found' to every non-Computer-Use tool call — and it is the driver's
only dispatch point. Neither AiFunctions nor OnCallToolFunction ever ran. Restored.
Behaviour change: tools that silently returned "not found" with Gemini now execute.
Shell output was decoded with TEncoding.UTF8.GetString, which validates its input and
raises EEncodingError. cmd.exe writes in the console OEM codepage (cp850 on a Spanish
Windows) and even its own banner carries accents, so the component died on the first
command. Invisible in English (pure ASCII) and on Linux (bash does emit UTF-8). Decoding
now falls back to the OEM codepage. Two more, found while exercising it on Linux: stderr was
dropped whenever the sentinel arrived in the same read, and a timeout left the session
permanently unusable (the Restart was written but commented out).
TAiMemory isolated namespaces in its searches, but Get, Update, Delete, Link and
Unlink addressed memories by id alone — and ids are sequential, so an agent could read,
change or delete another namespace's memories by guessing one, including through the
memory_delete / memory_link MCP tools. ImportFromJSON also honoured the namespace field
of the JSON and could write into another namespace. Every id-based operation now requires the
active namespace (a foreign id behaves exactly like a missing one), and imports always land in
the active namespace. Reported responsibly in #127.
Breaking for custom storages: the id-based methods of
IAiMemoryStoragenow take the namespace. The bundled SQLite storage is updated; a custom implementation must add the parameter.
With Tool_choice := 'required' (or a named function) the driver re-sent the forcing on
every round, including the one that returns tool results, so the model had to call a tool
again each time and the agentic loop never ended — 231 requests on claude-sonnet-5 before
it was killed. TAiChat.Tool_choice now reads auto in those rounds, which fixes every driver
at once. The first call of a turn is still forced.
The constructor used to set DriverName := 'Claude', which always overrode the driver of an
assigned TAiSkill. It is now empty and resolves node → skill → 'Claude', so a node without
a skill behaves exactly as before and forms saved with the old default keep 'Claude'
explicitly. See the skills section below for the rest of the precedence fix.
TAiQwenChat (Source/Chat/uMakerAi.Chat.Qwen.pas, driver name Qwen) talks to DashScope's
OpenAI-compatible endpoint (international region by default; key in DASHSCOPE_API_KEY).
Hybrid Qwen models think by default on the API side, so the driver always sends
enable_thinking: off unless cap_Reasoning is in ModelCaps, with ThinkingLevel mapped to
thinking_budget. Thinking-only models (qwq-plus, *-thinking-*) and open-weight models
(which only think when streaming) are handled for you. Registered models are the ones tested
live: qwen3.8-flash (default), qwen3.8-max, qwen3.7-plus, qwen3-vl-flash,
qwen3.8-omni-flash with vision; qwen3-max, qwen-plus/flash/turbo, qwen3-coder-plus/flash;
and qwq-plus, which only answers when streaming and is registered as asynchronous.
Beyond chat, the same key covers the rest of Model Studio, all tested live from Delphi:
Image generation and editing (cap_GenImage): qwen-image-3.0, qwen-image-2.0,
qwen-image-max, z-image-turbo, wan2.7-image. Attach one to three images to the prompt and
the same call edits them (qwen-image-edit-plus by default), keeping the original aspect ratio
unless you set a size. The driver downloads the result into MediaFiles.
Video (cap_GenVideo, Wan): text to video, image to video (attach one image) or first
and last frame (attach two). 720p by default instead of the API's 1080p; VideoParams.Params
passes through (duration, audio, seed...). Wan 2.5+ videos come with an audio track.
Text to speech (cap_GenAudio): qwen3-tts-flash, voice and language from TtsParams.
Transcription: qwen3-asr-flash in cmTranscription, where the prompt is passed as
context so proper names come out right. A text model with cap_Audio in SessionCaps uses it
to transcribe before answering, and qwen3.8-omni-flash understands audio natively.
Realtime (TAiRealtimeConnection, new unit uMakerAi.Realtime.Qwen): DriverName := 'Qwen'
for voice conversation, 'QwenSTT' for live transcription and 'QwenTranslate' for simultaneous
translation with a translated voice. Same events as the Grok and OpenAI drivers; nothing in the
realtime module changed. Driver-specific settings (voice, instructions, target language) go in
the connector's new DriverParams, which works for every realtime driver. TAiQwenRealtimeTTS goes the other way — text in, audio out while it
is generated — so an LLM answer can be spoken as it streams (first audio ~0.5 s after the first
text; 2.5 s from question to voice with qwen3.8-flash).
Text translation with qwen-mt-plus/flash/turbo/lite: set TranslateTo (and optionally
TranslateFrom, TranslateDomain, a TranslateTerms glossary) and each message is translated.
The driver sends only the latest message, as the API requires, and fixes plus/turbo streaming,
which repeats the accumulated text in every chunk.
Demo 089-QwenShowcase walks through all of it with one key.
Custom voices: TAiQwenVoices clones a voice from a sample or designs one from a text
description, and lists or deletes them. Put the returned id in TtsParams.Voice; the driver
switches to the TTS model that voice requires. Clone only voices you have consent to use.
Embeddings: TAiQwenEmbeddings (driver Qwen), text-embedding-v4 by default.
Rerank: TAiQwenRAGReranker plugs qwen3-rerank into TAiRAGVector.Reranker, up to 500
passages per call, with an optional task instruction.
MakerAI now speaks SKILL.md, the format of Claude's Agent Skills and of the PPM registry's
skill packages: YAML frontmatter (name, when to use it) plus Markdown instructions. One parser
(uMakerAi.Skills.Format) serves the whole framework, from a string, a file, a folder or the
registry.
TAiSkills (new, Source/Tools/uMakerAi.Tools.Skills.pas) gives any chat with function
calling on-demand skills. The model sees only a one-line-per-skill catalog in the description
of use_skill and loads the full instructions when it needs them, so dozens of skills cost no
tokens until used. Folder-based skills can ship supporting files, read with read_skill_file,
which is confined to the skill folder (no .., absolute paths, links or binaries, never
executes anything). Veto and audit events; guardrails apply as to any tool. Live, 9/9 on
OpenAI, Claude and Groq: the right skill for each request, none for an unrelated one, and
use_skill → read_skill_file chained when the instructions asked for it.TAiSkill.FromPPM works. It requested a URL that returns the website's HTML and a JSON
format no package publishes; it now downloads the real SKILL.md ('code-review' also finds
skill-code-review). New FromFolder / FromSkillFile; the JSON format still works for local
files. A SKILL.md never supplies an API key.TLLMNode respects its skill. New ResolveConfig: driver from the node, else the skill,
else Claude; the skill's model only if it belongs to that driver; the skill's system prompt
followed by the node's. Previously the skill's driver was always overridden and switching
driver lost the skill's model and key.TAiPrompts loads local skills (LoadSkillFromFile, LoadSkillsFromFolder) and
ApplySkill copies one into any SystemPrompt. Registry versions are now picked by semver.Guides: Docs/Version 3/uMakerAi-Skills.EN.md (Spanish: uMakerAi-Skills.md). Demo 091-Skills.
OnReceiveDataEnd received 'Done'#13#10'Done': the end of the stream re-added the
accumulated text. Affected all drivers built on the common parser (verified on Groq and
DeepSeek; Kimi, Grok and Mistral now return it once too).gpt-oss sends
executed_tools inside each delta, in two chunks per tool; the parser only looked at the
top level, the format of the retired groq/compound. They are now merged and delivered as
in the synchronous path.llama-3.1-8b-instant and
llama-3.3-70b-versatile no longer exist and were the driver's default, so a Groq connection
without an explicit model came back empty. The default is now openai/gpt-oss-20b, and both
old names are aliases (to gpt-oss-20b and gpt-oss-120b), so existing code keeps working.
groq/compound was removed without a replacement. qwen/qwen3.6-27b was registered with a
token limit the API rejects; fixed, and qwen/qwen3.8-27b added. Demo 014 now runs Groq's
code interpreter on gpt-oss-20b (--groq).TryGetValue<TJSONArray> missed the second form, the
coordinate was lost and the action landed on (0,0): a click in the screen corner, after
which the model retried until it ran out of turns. Affected coordinate,
start_coordinate and region, i.e. click, double/triple click, drag and zoom.traceparent propagation through _meta works. Fixed
otel.scope.version, hardcoded to 3.5 while the framework was on 3.7.libpq.so.5).CheckSynchronize in console apps and services:
every event is dispatched with TThread.Queue, so without a message loop no event ever
fires — not even OnError.Both vendor APIs changed under our feet, and one of them had gone silently dead. Claude was broken: the driver still declared computer_20251124, a tool type the Anthropic API now rejects for every model. It is now computer_toolset_20260801, which takes no parameters and explodes the old single computer tool into 17 individually named tools. OpenAI joins natively with gpt-6-astra and the parameterless computer tool, which sends a whole batch of actions per turn — the driver runs them in order and answers with one final screenshot.
Both APIs converged on the same design: the tool declares no screen dimensions (the model infers them from the screenshot) and coordinates come back as pixels of the image you sent.
TAiGLMChat brings a 14th provider: OpenAI-compatible endpoint, explicit thinking control (the API ships it ON by default, the driver decides), reasoning_content captured and re-sent across turns, and free tiers (glm-4.7-flash, glm-4.6v-flash).
RAG on pgvector (OFFSET was trimming instead of paginating; the vector did not survive the round trip), token and cache accounting across OpenAI, Claude and MakerAi streams, a race where the model travelled through the global registry, tool-calling continuation off the main thread, and reasoning no longer leaking into the user-visible answer.
The Model Context Protocol dropped sessions and the initialize handshake. MakerAI implements the new stateless revision on both sides and keeps talking to legacy peers: clients probe with server/discover and fall back automatically; the server serves modern per-request _meta requests statelessly while the legacy handshake and session gating keep working. Includes the MRTR pattern, so a tool can pause and ask the user for confirmation (OnInputRequired on the client, TAiAuthContext.InputResponses on the server).
TAiTelemetry exports OTLP traces to any standard collector (Jaeger, Grafana Tempo, Langfuse, Arize Phoenix) following the GenAI semantic conventions. Spans cover chat turns with token usage, tool executions, agent graphs and nodes, RAG retrieval and MCP requests — with W3C traceparent propagated through MCP _meta, so a client and a server in different processes share one distributed trace. Opt-in, zero overhead when disabled.
If MCP is the agent-to-tool layer, A2A (Linux Foundation) is the agent-to-agent layer. TAiA2AServer publishes any agent graph as a standard A2A agent (Agent Card + JSON-RPC), TAiA2AClient consumes remote agents, and TAiA2ARemoteAgentTool federates: a node in your graph can delegate its work to a remote agent — including one written in another language or framework. Demo: 072-A2AFederation.
TAiGuardrails intercepts every tool call before it executes (allowlists, blocklists, forbidden argument patterns, programmatic veto) — blocked calls never run and the LLM gets the reason so it can replan. TAiEvalRunner brings systematic evaluation: fluent test cases against any target, deterministic checks plus optional LLM-as-judge, with ToJSON reports for CI.
Tests/RegressionSuite/ — 17 in-process cases covering MCP, agents, A2A, guardrails and evals. No API keys, under a second, exit code for CI. Built on TAiEvalRunner itself.
Capability configuration now lives in a single typed surface: ModelConfig.ModelCaps / SessionCaps / Tool_Active / ThinkingLevel moved out of the string-based Params/RTTI channel, with per-field user pins and transparent compatibility migration — existing code keeps working unchanged.
TAiGrokRealtimeChat — xAI Grok Voice speech-to-speech (function calling, session resumption with replay, binary audio transport, ephemeral tokens)TAiOpenAiRealtimeTranslate — continuous streaming speech translation (one WebSocket per direction; demo 071-VoiceBridgeTranslate)TAiRealtimeVoiceBase — shared full-duplex base; voice events flow through the universal TAiRealtimeConnectionClaude 5 family (adaptive thinking, FastMode, compaction, server-side fallbacks) · Gemini 3.5/3.6 + Nano Banana GA · Mistral Voxtral TTS + OCR 4 · Kimi K3 · DeepSeek V4 (explicit thinking control) · Cohere Command A+ · Groq qwen3.6 · xAI grok-4.3/4.5/build — with retired-model cleanup and compatibility aliases throughout.
TAiGrokChat now generates video with grok-imagine (async job + polling + mp4 as TAiMediaFile, new VideoDurationSeconds property) and images with grok-imagine-image — activated by cmVideoGeneration/cmImageGeneration or the [cap_GenVideo]/[cap_GenImage] gaps.
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 DriverNameTAiOpenAiRealtimeSTT — full OpenAI Realtime API implementation (24 kHz PCM16, VAD modes, streaming transcription)OpenAI's new transcription models (Aug 2026) are fully integrated — better accuracy on real-world audio, accents, numbers, specialized terminology and loud background noise:
TAiOpenAiRealtimeSTT now defaults to gpt-live-transcribe, with new context properties: TranscriptionPrompt (free-form topic), TranscriptionKeywords (domain terms), Languages (multi-language guided autodetection) and LowDelayTAiOpenAiAudio gains tmGptTranscribe / tmGptLiveTranscribe with TranscriptionKeywords + TranscriptionLanguages for REST/batch transcriptionwhisper-1, gpt-4o-transcribe) remain available — they're still required for subtitles (SRT/VTT), word timestamps and diarization (gpt-4o-transcribe-diarize), which the new models don't support; the components degrade formats safely per modelgpt-live-transcribe with contextual prompts and guided language detection; diarized channels stay on gpt-4o-transcribe-diarizeFull-duplex voice conversation with xAI's Grok Voice models (grok-voice-think-fast-2.0) over a single WebSocket — the user speaks, Grok listens, reasons and answers back with voice:
TAiGrokRealtimeChat — complete driver for wss://api.x.ai/v1/realtime (OpenAI Realtime-compatible protocol, 24 kHz PCM16)TAiRealtimeVoiceBase — new base class for full-duplex voice drivers; adds OnAssistantText, OnAssistantTextDelta, OnAudioChunk, OnAudioDone (shared with TAiMakerAiRealtimeChat)OnTranscriptDelta / OnTranscriptCompleted), server VAD, streamed assistant text and TTS audioTAiFunctions component (local functions + MCP) and Grok invokes your Delphi code mid-conversation — the driver handles the whole round-trip (execution on worker threads, function_call_output, continuation)EnableWebSearch / EnableXSearch — executed server-side by xAIVoice (eva, ara, rex, sal, leo or custom voice_id), Instructions, ReasoningEffort (high / none for lower latency), OutputSpeed, Keyterms (transcription biasing), PronunciationReplace (TTS corrections), automatic regional language hints (es→es-MX, pt→pt-BR)ForceMessage() — scripted TTS utterance bypassing the model (IVR prompts, disclosures)EnableResumption + ConversationId — reconnect and the server replays the cached turns (transcripts, tool calls and outputs; 30-min window)BinaryAudio := True — raw PCM over WebSocket binary frames, ~33% less bandwidth than base64MintEphemeralToken() on your backend + EphemeralToken on the client — the API key never leaves the serverfile_search over xAI Collections (FileSearchCollections) and remote MCP servers via CustomToolsJsonTAiRealtimeConnection too — just set DriverName := 'Grok'uses uMakerAi.Realtime.AiConnection, uMakerAi.Realtime.Grok;
Voice := TAiRealtimeConnection.Create(nil);
Voice.DriverName := 'Grok';
Voice.ApiKey := '@GROK_API_KEY';
Voice.Language := 'es';
Voice.OnTranscriptCompleted := HandleUserText; // what the user said
Voice.OnAssistantText := HandleGrokText; // what Grok answered
Voice.OnAudioChunk := HandleGrokAudio; // Grok's voice (PCM16 24 kHz)
Voice.Connect;
// ... stream microphone audio via Voice.SendAudioChunk(Data) ...
// For file-based audio (non-continuous), close the turn explicitly:
// Voice.CommitAudio; TAiGrokRealtimeChat(Voice.Instance).CreateResponse;
New ChatMode value for automatic two-pass routing:
IAiImageTool, IAiSpeechTool, IAiWebSearchTool, etc.)TAiAgentManager.Run declared virtual — proper subclassing now supportedFJoinInputs cleared after each execution; eliminates premature firing on retries and loopsTChatInput.EnterAsSend — new property (default False): Enter sends the prompt, Shift+Enter / Ctrl+Enter inserts a line breakTChatBubble — eliminated spurious vertical scrollbar (ShowScrollBars := False)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 │ └───────────────────────────┘
│ │ │ A2A server/client │
└────┬────┘ └─────────┬──────────┘
│ │
┌────▼──────────────────▼──────────────────────────────────────────┐
│ 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 │
│ GLM · Qwen · 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 │ │ SQL Server │ │ TAiFunctions bridge│
│ ComputerUse│ │ HNSW · BM25 · RRF │ └─────────────────────┘
│ Skills │ │ Rerank · Documents │
└─────────────┘ └─────────────────────┘
┌──────────────────────────────────────────────────────────────────┐
│ Cross-cutting: Guardrails · Evals · OpenTelemetry · TAiMemory │
│ Jev (calibrated decisions: routing, guards, rerank, labeling) │
└──────────────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────────────────────┐
│ Realtime Voice — parallel WebSocket stack │
│ TAiRealtimeConnection · OpenAI STT/Translate · Grok Voice S2S │
│ Qwen voice/STT/translate/TTS · MakerAI │
│ Pure-Pascal RFC 6455 + TLS (SChannel / OpenSSL / Android) │
└──────────────────────────────────────────────────────────────────┘
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-6-sol'; // leave Model empty to get the driver's default
AiConn.Params.Values['ApiKey'] := '@OPENAI_API_KEY'; // resolved from the environment variable
// Switch to Gemini without changing anything else
AiConn.DriverName := 'Gemini';
AiConn.Model := 'gemini-3.8-flash';
AiConn.Params.Values['ApiKey'] := '@GEMINI_API_KEY';
// Or to GLM (Zhipu / Z.ai) — glm-4.7-flash is free
AiConn.DriverName := 'GLM';
AiConn.Model := 'glm-4.7-flash';
AiConn.Params.Values['ApiKey'] := '@GLM_API_KEY';
Legend: ✅ Native | ⚠️ Tool-Assisted bridge | ❌ Not Supported
¹ Computer Use is opt-in.
cap_ComputerUsehands the model the real mouse and keyboard, so no model enables it by default — you add the capability yourself (see the Computer Use section below). Native support: OpenAIgpt-6-astra; Claudeclaude-opus-4-8/-opus-5/-sonnet-5/-fable-5. Gemini is marked ⚠️ because the registry still points at thegemini-2.5-computer-use-previewmodel (3.7/3.8 Flash list computer use as a preview tool, not yet wired or tested). The Claude 5.5 / Fable 5.1 models use the samecomputer_toolsetbut have not been runtime-tested with it yet.
Every one of the 108 components has its own palette icon. The tile color identifies the provider (maroon = MakerAI framework, black = OpenAI, blue = Gemini, purple = Qwen, teal = Jev…).

The full sheet groups them by
category, with the class name and the palette tab each one lands on. Icons are generated by
Source/Resources/gen_icons.py and the sheet by gen_palette_sheet.py; see
Source/Resources/CLAUDE.md to add an icon for a new component.
Two complementary retrieval engines with their own query languages:
Vector RAG — semantic and hybrid search over document embeddings:
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
Graph RAG — knowledge graph with semantic search over entities and relationships:
MATCH (p:Person)-[r:WORKS_AT]->(c:Company)
WHERE c.city = 'Madrid' DEPTH 2
RETURN p, r, c
Graph-based multi-agent workflows with full thread safety:
TAIAgentManager — executes directed graphs of AI nodes via thread poolTAIAgentsNode — single execution unit; runs an LLM call, a tool, or custom logicTAIBlackboard — thread-safe shared state dictionary between all nodeslmFanout (parallel broadcast), lmConditional (routing), lmExpression (binding), lmManualjmAny (first arrival wins), jmAll (wait for all inputs)IAiCheckpointer persists full agent state between process restarts; built-in implementations: TAiFileCheckpointer (JSON files) and TAiDatabaseCheckpointer (FireDAC — SQLite, PostgreSQL, Firebird, etc.)Node.Suspend(Reason, Context) pauses a node and saves the checkpoint; TAiWaitApprovalTool provides a drop-in approval tool; resume with ResumeThread(ThreadID, NextNode, HumanInput)TAiChatConnectionFull dual-era implementation of the MCP standard for both consuming and exposing tools: supports the stateless spec revision 2026-07-28 (per-request _meta, server/discover, MRTR elicitation) and interoperates automatically with legacy peers that still use the initialize handshake.
MCP Server — expose Delphi functions as MCP tools, callable by any MCP client (Claude Desktop, AI agents, etc.):
_meta identity + OnClientConnect vetting); legacy clients keep the initialize handshake and Mcp-Session-Id session gatingresultType: "input_required" + opaque requestState) — working example in Demos/031-MCPServer/uTool.ConfirmDemo.pasTAiFunctions → IAiMCPTool — any existing TAiFunctions component becomes an MCP server instantlyTAiMCPResponseBuilder for structured responses (text + files + media)MCP Client — consume any external MCP server from your Delphi app:
server/discover first and falls back to the legacy handshake automatically; the negotiated mode is exposed in NegotiatedProtocolOnInputRequired event resolves MRTR elicitations (retry loop with requestState echo; assigning the handler declares the elicitation capability)TAiFunctions component alongside native function definitionsQuick way to try TMCPClientHttp against a public MCP server — this example uses Parallel Search, a third-party commercial service (Parallel Web Systems, not affiliated with MakerAI) that exposes web_search / web_fetch tools over MCP:
var
MCPClient: TMCPClientHttp;
begin
MCPClient := TMCPClientHttp.Create(nil);
try
MCPClient.URL := 'https://search.parallel.ai/mcp';
if MCPClient.Initialize then
Writeln(MCPClient.Tools.Text);
finally
MCPClient.Free;
end;
end;
Note: at the time of writing (Aug 2026) Parallel offers a rate-limited free tier that works without an API key, but pricing, limits and availability are set by Parallel and may change at any time — check their terms before relying on it in production. Be aware that your search queries and any fetched URLs are sent to their servers. MakerAI has no relationship with this service; it is shown only as a convenient public endpoint for testing the MCP HTTP client, and any spec-compliant MCP server works the same way.
⚠️ SSE transport deprecation (spec 2026-07-28): the classic HTTP+SSE transport (GET
/sse+ POST/messages) was formally moved to Deprecated state by MCP spec revision 2026-07-28 under the project's feature-lifecycle policy, which mandates a minimum 12-month window. Its earliest possible removal from the spec is July 2027 — actual removal happens in the first spec revision published after that date, at the maintainers' discretion, and may come later. Removal deletes the transport from future spec revisions only: existing MakerAI SSE endpoints keep working between themselves, but third-party clients (Claude Desktop, official SDKs) will progressively drop it. Use the HTTP or StdIO transports for anything new. Note that SSE as a streaming response format survives inside Streamable HTTP — only the standalone HTTP+SSE transport is being retired.
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.
TAiComputerUseTool lets a model look at the screen and drive the real mouse and
keyboard. One canonical action model is shared by every provider, so the same
executors and the same event handlers work regardless of who is driving:
// Opt-in: no model ships with cap_ComputerUse enabled
TAiChatFactory.Instance.RegisterUserParam('OpenAi', 'gpt-6-astra',
'ModelCaps', '[cap_Image, cap_Reasoning, cap_ComputerUse]');
TAiChatFactory.Instance.RegisterUserParam('OpenAi', 'gpt-6-astra',
'SessionCaps', '[cap_Image, cap_Reasoning, cap_ComputerUse]');
AiConn.ChatTools.ComputerUseTool := MyComputerUseTool; // + OnExecuteAction / OnRequestScreenshot
The two APIs refreshed in 2026 (OpenAI and Claude) converged independently on the same
design: the tool declares no screen dimensions — the model infers them from the
screenshot — and coordinates come back as pixels of the image you sent.
ScreenWidth/ScreenHeight are therefore local-only now: they must match the image you
actually submit, because that is the divisor used to translate coordinates back to
physical pixels.
OnSafetyConfirmation gates risky actions (human-in-the-loop); denying
is the default when no handler is assignedSendInput) and Linux/X11
(TAiLinuxExecutor, xdotool + scrot), all runtime-tested. A macOS executor (CGEvent) is
written but has not yet been compiled or tested on macOS. They are interchangeable: an
executor is just the pair of handlers, so TAiComputerUseTool itself is platform-agnosticToolCall.Response from OnCallToolFunction and the driver will not
execute locally — a headless process can forward the call to whoever owns a screenAreaLeft/AreaTop/AreaWidth/AreaHeight select a sub-region;
multi-monitor works but is still lightly tested066-ComputerUseTest (Windows, real desktop — -provider=openai|claude|gemini,
-prompt=..., -autorun, run.log next to the executable), 082-ComputerUsePassthru
(who executes the call: delegated, missing tool, local — self-verifying, does not touch the
screen) and 083-ComputerUseLinux (real agentic loop on Xvfb)A parallel component stack for live audio over WebSocket, with the same universal-connector pattern as chat (TAiRealtimeConnection.DriverName):
DriverParams on TAiRealtimeConnection — driver-specific settings (Voice, Instructions, TargetLanguage…) as Property=Value lines, applied to whichever driver is activeTAiRealtimeVoiceBase — shared base for full-duplex drivers: OnAssistantText[Delta], OnAudioChunk, OnAudioDone, on top of the STT events (OnTranscriptDelta/Completed, OnSpeechStarted/Stopped)TAiFunctions component and the model invokes your Delphi functions mid-conversationTAIVoiceMonitor (mic) → thread-safe PCM16 resampler → provider rate (24 kHz); push audio from any source via SendAudioChunkTAiWSClient, RFC 6455) with pluggable TLS: Windows SChannel (zero DLLs), OpenSSL (Linux/macOS), javax.net.ssl (Android). The POSIX transport verifies the server certificate — chain and hostname — with InsecureSkipVerify as an explicit opt-outFirst Delphi implementation of A2A 1.0 (Linux Foundation), certified against the official TCK (MUST 89/89, SHOULD 8/8):
TAiA2AServer exposes any TAIAgentManager graph as an A2A agent: Agent Card at /.well-known/agent-card.json, SendMessage / GetTask / CancelTask / ListTasks, SSE streaming, push notifications, bearer auth, a pool of managers for concurrent tasks, and human-in-the-loop (a suspended node becomes input-required)TAiA2AClient consumes remote agents; TAiA2ARemoteAgentTool federates a graph node to a remote agent, and TAiA2AAgentTool exposes a remote agent to a chat as a function072-A2AFederation, 074-A2AOrchestration, 079-A2ASutAgent, 080-A2APushNotificationsSkills use the SKILL.md format (Claude Agent Skills / PPM registry): YAML frontmatter with a name and when to use it, plus Markdown instructions. The same file works in a chat, an agent node or a prompt:
TAiSkills — plug it into TAiFunctions and the model sees only a one-line catalog in use_skill; it loads the instructions it needs, and reads supporting files with read_skill_file (confined to the skill folder). Works with any provider that supports function callingTAiSkill + TLLMNode.Skill — a skill as the fixed personality of an agent nodeTAiPrompts.ApplySkill — copy a skill into any SystemPromptSkills\<name>\SKILL.md), a file, code, or the PPM registry (LoadFromPPM('skill-code-review'))Docs/Version 3/uMakerAi-Skills.EN.md · Demo: 091-SkillsTAiGuardrails — assigned to TAiFunctions.Guardrails, it checks every tool call (local, MCP or AutoMCP) before it runs: allow/block lists with wildcards, forbidden argument patterns, a pluggable semantic Classifier and an OnCheckToolCall veto. A blocked call never executes; the model gets the reason and can replanChatTools.PromptGuard — the input-side guardrail: checks the user's message before it reaches the modelTAiEvalRunner — fluent test cases (ExpectContains, ExpectRegex, ExpectEquals, ExpectJudge with an LLM judge, ExpectScore with a calibrated scorer) against any target, with text and JSON reports. The framework's own regression suite (117 cases, no API keys) is built on it073-GuardrailsEvalsTAiTelemetry exports traces over OTLP/HTTP (collector on localhost:4318: Jaeger, Grafana Tempo, Langfuse, Arize Phoenix) following the OpenTelemetry GenAI semantic conventions: chat turns with token usage, tool executions, agent graphs and nodes, RAG searches, MCP and A2A requests, and skill loads. The W3C traceparent travels through MCP _meta and A2A, so a call that crosses processes stays in one trace. Zero overhead when disabled. Validated against a real Jaeger.
Persistent semantic memory on SQLite: FTS5 lexical search, optional embeddings with hybrid RRF fusion, importance and decay, TTL, links between memories, and namespaces that isolate agents or projects. Context(prompt) builds a memory block ready for the system prompt, and uMakerAi.Memory.MCP exposes it as MCP tools. Demo: 076-Memory.
TAiJev wraps Jev (TypeSafe AI), a model that does not generate text: it answers typed questions (choice, score, yes/no) with calibrated probabilities, for the fast and cheap decisions that would otherwise cost a full LLM call. Adapters plug it into the framework: agent routing (TAiJevRouterTool), SmartDispatch, tool-call and input guardrails, eval scoring, RAG reranking with injection filtering, bulk labeling (TAiJevBatchLabeler) and model routing (TAiJevModelRouter, the cheapest model that can handle each request), with usage metering for billing. Needs TYPESAFE_API_KEY. Demos 084–088.
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 needscap_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_WebSearch, cap_Reasoning, cap_CodeInterpreter, cap_Memory, cap_TextEditor, cap_ComputerUse, cap_Shellcap_GenImage, cap_GenAudio (TTS), cap_GenVideo, cap_GenReport, cap_ExtractCodeThinkingLevel controls reasoning depth across the full effort ladder: tlNone, tlMinimal, tlLow, tlMedium, tlHigh, tlXHigh, tlMax (tlDefault = let the provider decide). Each driver maps it to what its models accept — for example Gemini 3 has no minimal and cannot turn thinking off, so both are sent as LOW.
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 contentTAIChatInput — 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 automaticallyClassic components — FMX-layout-based, simpler to subclass:
TChatList — scrollable message container with Markdown rendering, code blocks, copy buttonsTChatBubble — individual message bubble (user / assistant / tool)TChatInput — text input bar with voice recording, file attachment, and send buttonBoth 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 InspectorModel property lists all models for the selected providergit 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/Memory
Source/Packages
Source/RAG
Source/Realtime
Source/Resources
Source/Tools
Source/Utils
Source/WebSocket
Compile and install in this exact order:
Source/Packages/MakerAI.dpk — Runtime core (~100 units)Source/Packages/MakerAi.RAG.Drivers.dpk — database back-ends via FireDAC: PostgreSQL/pgvector, SQL Server and SQLite for RAG, graph RAG on PostgreSQL, DB checkpoints for agents, and TAiMemorySource/Packages/MakerAi.UI.dpk — FMX visual components (requires Skia)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. On TAiChatConnection the key goes through Params (it has no ApiKey property); direct drivers (TAiOpenChat, TAiClaudeChat...) and TAiEmbeddingConnection do have an ApiKey property:
AiConn.Params.Values['ApiKey'] := '@OPENAI_API_KEY'; // reads OPENAI_API_KEY from environment
AiConn.Params.Values['ApiKey'] := '@CLAUDE_API_KEY'; // reads CLAUDE_API_KEY
AiConn.Params.Values['ApiKey'] := '@GEMINI_API_KEY'; // reads GEMINI_API_KEY
AiConn.Params.Values['ApiKey'] := '@GROK_API_KEY'; // reads GROK_API_KEY (xAI chat and Grok Voice)
AiConn.Params.Values['ApiKey'] := 'sk-...'; // or set a literal key directly
Open Demos/DemosVersion31.groupproj to access all demos.
https://registry.cimamaker.com — new default in TAiFunctions (AutoMCP, PPM search), TAiPrompts, TAiSkill, the SKILL.md client and the demos. Code that sets registry.pascalai.org explicitly keeps working while that host stays upmax_output_tokens — Max_Tokens was silently ignored in the whole driver. response.incomplete now closes the stream with its finish reason, and response.failed / stream error events end the turn through the error path instead of leaving the caller waiting for its timeouttools/call on a shared TMCPClientSSE lost responses (a call waited 180 s and came back empty) — two races on the request idTAiMCPServer.BindAddress (or the MCP_BIND_ADDRESS environment variable) binds SSE/HTTP MCP servers to one local IP; they always listened on 0.0.0.0reasoning_effort reaches the grok-4 models and streaming returns usage (it came back as zeros)EnforceStrictSchema crashed on JSON Schema union types ("type": ["integer", "string"]); Claude code_execution files keep their real namesMakerAi.UI and MakerAi.RAG.Drivers packages had none because only MakerAI linked a resource. Each package now links its own .res. Generator and category sheet in Source/Resources/C:\Temp unconditionally — the SChannel TLS transport (schannel_diag.txt), the Gemini Veo upload (responses.txt, which also leaked a stream) and the MakerAI realtime driver; the MCP client shutdown log did so in every Debug build. All off by default (opt-in: MAKERAI_SCHANNEL_DIAG, MAKERAI_MCP_SHUTDOWN_LOG). MakerAiGrp.groupproj now builds in the documented order and demo 059 lost an absolute E: path. Reported in #130TAiMemory.Delete, Link and Unlink return Boolean — after the namespace isolation of 3.8 an operation on a foreign id does nothing, but the memory_delete / memory_link MCP tools still answered "deleted"/"linked". They now return False (existing calls still compile) and the tools answer not_found. IAiMemoryStorage is unchangedTAiOpenAiLiveChat — OpenAI GPT-Live (gpt-live-1, DriverName OpenAiLive), full-duplex voice: it listens while it speaks and delegates reasoning. By default to a Responses model run by OpenAI, with web search and your TAiFunctions executed locally; or, assigning DelegateChat, to any TAiChatConnection (Claude, Ollama, an agent graph, RAG) — the driver builds the task from the transcript and speaks the answer back. Turns are rebuilt from the session timeline, so overlapping speech no longer splits answers. Tested live: conversation, interruptions, a 2-minute story, local function (≈ 2 s delegation round trip) and DelegateChat (≈ 4.9 s). Demo 092-GPTLiveVoice (FMX: microphone, speaker, delegation mode, local functions, anti-echo speaker mode)/v1/systemone: nimble, tev1, Cloudflare's clef/clef-flash). TAiJev works as is with Url := 'http://localhost:11434/v1/'; the eight Jev adapters gained a Url property (keeping parallelism in the RAG reranker and the batch labeler), TAiJev.Ask accepts images for Clef (PNG/JPEG/WebP, validated by their bytes), and the TypeSafe default price is no longer charged on other servers. Tested live with nimble (routing, prompt guard and parallel batch labeling, at zero cost) and with clef 27B on images (PNG/JPEG/WebP and a control chart told apart at 0.99). clef-flash fails in Ollama 0.35.1 itself (ollama#18769); clef needs a smaller context (num_ctx 4096) to fit in 24 GB of VRAMTAiOpenAiAudio and TAiOpenAiSpeechTool default to gpt-transcribe and gpt-4o-mini-tts (before whisper-1 and tts-1, which OpenAI shuts down on 2027-02-26 and 2027-01-06). Forms that kept the default switch automatically. gpt-transcribe returns JSON only: srt/vtt/verbose_json, timestamps and logprobs downgrade and are reported in TTranscriptionResult.Warning — set TranscriptionModel := tmWhisper1 to keep them until the shutdown. gpt-4o-mini-tts is also deprecated (no replacement on /audio/speech yet) but sounds better and supports TTSInstructions. Tested live (speech → transcription round trip). TAIWhisper is unchangedtools/list — the schema of each tool was cloned and the original leaked (~32 blocks per request), since a June change. IAiMCPTool.GetInputSchema now documents what both implementations already did: it returns a new object the caller owns. Custom IAiMCPTool implementations must not return a cached fieldtools/list response on every Initialize (HTTP and base transports), and TAiRealtimeFactory never freed its driver dictionary — both reported as leaks when closing an app with MCP or realtime. Regression case mcp.initialize.no-leakDriver=postgres in its ini; values starting with @ are read from the environment, e.g. Password=@PGPASSWORD). Tested at runtime; SQL Server 2025 stays the default. Demo 092 consumes it by voice through MCP, with a read-only TAiGuardrails policy, and gained a quick guide of example questionsTAiOpenAiAudio.Transcribe left the raw JSON in Text when the model could not honour the requested format — e.g. gpt-transcribe with trfText, or a gpt-4o model with trfSrt/trfVtt: the request was downgraded to json but the response was parsed as plain text. It is now parsed with the format actually requested. New TTranscriptionResult.Warning: one line per thing that was requested but not honoured (format downgraded, timestamps, logprobs or known speakers ignored by the model) and a deprecation notice for the old modelswhisper-1, gpt-4o-transcribe, gpt-4o-mini-transcribe and gpt-4o-transcribe-diarize shut down on 2027-02-26, and tts-1, tts-1-hd and gpt-4o-mini-tts on 2027-01-06. Their replacements have no srt/vtt/verbose_json, timestamps, logprobs, diarization or translation to English, so those features (and TAiOpenAiAudio.TranslateToEnglish) end on that date. Marked in the enums, the catalog and the docs; defaults are unchanged for now. Realtime docs and demos no longer use the retired gpt-4o-realtime-previewtool_choice looped forever — required (or a named function) was re-sent on every round, including the one that returns tool results, so the model had to call a tool again each time: measured on claude-sonnet-5, 231 requests until killed. TAiChat.Tool_choice now reads auto in follow-up rounds, which fixes every driver at once. Behaviour change: forcing applies to the first call of a turn onlyTAiOpenChat dropped on a form used gpt-5, not the documented default — the base constructor set gpt-5 and the driver only assigned its own default when the model was empty. The OpenAI default is now gpt-6-sol (the successor of gpt-5.1 at the same price point) for both the component and TAiChatConnection; gpt-6-sol and gpt-6-luna registered. TAiMakerAiChat, which inherits from it, now defaults to mk-gpt-oss-20b like its connection. GPT-6 rejects effort minimal; it is sent as low. Tested liveauto instead. tlXHigh/tlMax now reach Claude as xhigh/max. claude-opus-4-1, retired on 2026-08-05, is now an alias of claude-opus-5-5. Tested live. The default stays claude-haiku-4-5 (still the current Haiku)gemini-2.5-flash (driver default) is restricted to accounts that already used the 2.5 family, and the transcription and web-search tools defaulted to gemini-2.0-flash, shut down on 2026-06-01. The driver, TAiGeminiWebSearchTool and transcription now default to gemini-3.8-flash, and TAiGeminiSpeechTool TTS to gemini-3.8-flash-tts. gemini-3.8-flash, gemini-3.7-flash and both 3.8 TTS models registered; gemini-3-pro-preview and the three imagen-4.0-* (shut down) became aliases of their successors. Sampling is now omitted by version (3.5 and later) instead of a name list, which missed 3.7/3.8, and the new effort levels map to what Gemini 3 accepts (minimal is rejected by 3.7/3.8). Checked against the official docs; not runtime-tested (no API key). Forms saved with the old model keep itTAiMemory enforced namespaces only in searches — Get, Update, Delete, Link and Unlink addressed memories by id alone, and ids are sequential, so an agent could read, change or delete another namespace's memories by guessing one, including through the memory_delete / memory_link MCP tools. ImportFromJSON also honoured the namespace of the JSON. Every id-based operation now requires the active namespace (a foreign id behaves like a missing one) and imports land in the active namespace. Breaking for custom storages: the id-based methods of IAiMemoryStorage take the namespace. Reported responsibly in #127uMakerAi.Skills.Format, with a read-only PPM registry client: semver version resolution, skill- prefix fallback, clear errors on a missing package, a non-skill package or an HTML page). TAiSkills gives any chat with function calling on-demand skills: the model sees a catalog in use_skill and loads the instructions it needs; folder skills ship supporting files read with read_skill_file, confined to the skill folder. Live 9/9 on OpenAI, Claude and Groq. Guide: Docs/Version 3/uMakerAi-Skills.EN.md, demo 091-SkillsTAiSkill.FromPPM never worked — it requested a URL that returns the website's HTML and a JSON format no package publisThe AI Operating System for Delphi. 100% native framework with RAG 2.0, autonomous agents, MCP protocol, and universal LLM connector. Supports OpenAI, Claude, Gemini, Ollama, and more. Delphi 10.4+ (l
總覽
The AI Operating System for Delphi. 100% native framework with RAG 2.0, autonomous agents, MCP protocol, and universal LLM connector. Supports OpenAI, Claude, Gemini, Ollama, and more. Delphi 10.4+ (limited), full support from Delphi 12 Athens.
工具
尚無工具清單。遠端伺服器會在首次健康檢查後取得工具清單。
常見問題
在本頁複製適用於 Cursor、Claude Desktop、Claude Code 或 VS Code 的 stdio 設定。它使用發布者的安裝方式,而不是 PlugMCP 代理伺服器。
這筆記錄未列出必要的環境變數。
MakerAi 透過 stdio 在本機執行。
上次檢查時間:2026-11-12。 The AI Operating System for Delphi. 100% native framework with RAG 2.0, autonomous agents, MCP protocol, and universal LLM connector. Supports OpenAI, Claude, Gemini, Ollama, and more. Delphi 10.4+ (limited), full support from Delphi 12 Athens.