convez.ai
MCP ServerIntegração & APIsAvançado
gustavoeenriquez

MakerAI Suite — Sistema IA Nativo para Delphi

gustavoeenriquez/MakerAi

Ecossistema IA completo nativo em Delphi com RAG, agentes e MCP

Ver no GitHub
BomPluginScore · de 0 a 100

Framework completo de IA nativo para Delphi que vai além de API wrappers, oferecendo pipelines RAG, agentes autônomos, servidores MCP e componentes visuais. Suporta OpenAI, Claude, Gemini, Ollama e outros provedores com troca dinâmica em tempo de execução. Compatível com Delphi 10.4+ e Free Pascal 3.2+.

Instalação

$npx convez-ai gustavoeenriquez/MakerAi

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
218
Forks
64
Acompanhando
22
Saúde
42%
Último commit
há 1 semana
Versão
v3.9.0
Issues abertas
1
Contribuidores
3

Casos de uso

  • Construir sistemas inteligentes multi-agente em Delphi
  • Implementar pipelines RAG com busca vetorial e grafos
  • Integrar múltiplos provedores LLM com switching dinâmico
  • Criar interfaces de chat multimodal com componentes FMX
  • Expor ferramentas via MCP Protocol para ecossistema Claude

Veredito

Solução madura e completa para quem trabalha com Delphi e precisa de IA em produção. Vai muito além de wrappers simples, oferecendo arquitetura robusta de agentes e RAG, mas exige expertise técnica em Delphi para aproveitar seu potencial.

README

A tradução para o português deste README ainda está na fila.

MakerAI Suite v3.4 — The AI Ecosystem for Delphi

🌐 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.


MakerAI is more than an API wrapper

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.


🚀 What's New in v3.4

Delphi 13.1 Florence Support

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.

Selective Driver Registration

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;

Real-Time STT — TAiRealtimeConnection

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

cmSmartDispatch — Intelligent Chat Routing

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.)

Models Updated (May 2026)

ProviderNew / Updated Models
OpenAIgpt-5.4, gpt-5.4-mini, gpt-5.5, gpt-image-1
Claudeclaude-opus-4-7 (Adaptive Thinking), claude-sonnet-4-6, claude-haiku-4-5
Geminigemini-3.1-pro, gemini-3-flash, gemini-3.1-flash-lite, gemini-3.1-flash-image
Grokgrok-4-fast, grok-3, grok-code-fast-1
Mistralmagistral-medium/small, devstral, voxtral
Groqllama-4-scout/maverick, kimi-k2, qwen3, compound-beta
Kimikimi-k2, kimi-k2.5, kimi-k2-thinking
Coherecommand-a-03-2025, command-a-reasoning, command-a-vision

Agent Improvements

  • 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)

Bug Fixes

  • 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.

Bug Fixes (March 2026)

  • 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.


🏗️ Architecture

┌──────────────────────────────────────────────────────────────────┐
│  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 │   └─────────────────────┘
└─────────────┘   └─────────────────────┘

📡 Supported AI Providers

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

Direct Provider Components

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

ComponentProviderLatest Models
TAiOpenChatOpenAIgpt-5.4, gpt-5.4-mini, gpt-5.5, gpt-image-1
TAiClaudeChatAnthropicclaude-opus-4-7, claude-sonnet-4-6, claude-haiku-4-5
TAiGeminiChatGooglegemini-3.1-pro, gemini-3-flash, gemini-3.1-flash-lite
TAiGrokChatxAIgrok-4-fast, grok-3, grok-code-fast-1
TAiMistralChatMistral AImagistral-medium, devstral, voxtral
TAiDeepSeekChatDeepSeekdeepseek-reasoner, deepseek-chat
TAiKimiChatMoonshotkimi-k2, kimi-k2.5, kimi-k2-thinking
TAiGroqChatGroqllama-4-scout, llama-4-maverick, kimi-k2, qwen3
TCohereChatCoherecommand-a-03-2025, command-a-reasoning, command-a-vision
TAiOllamaChatOllamaAny local model
TAiLMStudioChatLM StudioAny local model
TAiGenericChatOpenAI-compatibleAny OpenAI-API endpoint

Universal Connector

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';

📊 Feature Support Matrix

FeatureOpenAI (gpt-5.2)Claude (4.6)Gemini (3.0)Grok (4)MistralDeepSeekOllama
Text Generation✅✅✅✅✅✅✅
Streaming (SSE)✅✅✅✅✅✅✅
Function Calling✅✅✅✅✅✅✅
JSON Mode / Schema✅✅✅✅✅✅✅
Image Input✅✅✅✅✅❌✅
PDF / Files✅✅✅⚠️✅❌⚠️
Image Generation✅❌✅✅❌❌❌
Video Generation✅❌✅❌❌❌❌
Extended Thinking✅✅✅✅✅✅⚠️
Speech (TTS/STT)✅❌✅❌❌❌⚠️
Web Search✅✅✅✅❌❌❌
Computer Use✅✅❌❌❌❌❌
RAG (all modes)✅✅✅✅✅✅✅
MCP Client/Server✅✅✅✅✅✅✅
Agents✅✅✅✅✅✅✅

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


🧩 Ecosystem Modules

🧠 RAG — Retrieval-Augmented Generation

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)

🤖 Agents — Autonomous Orchestration

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

🔗 MCP — Model Context Protocol

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 — AI × Deterministic Capabilities

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

Tool InterfaceWhat it doesImplementations
IAiPdfToolExtract text from PDFsMistral OCR, Ollama OCR
IAiVisionToolDescribe / analyze imagesAny vision model
IAiSpeechToolText-to-speech / speech-to-textWhisper, Gemini Speech, OpenAI TTS
IAiWebSearchToolLive web searchGemini Web Search
IAiImageToolGenerate imagesDALL-E 3, gpt-image-1, Gemini, Grok
IAiVideoToolGenerate videoSora, Gemini Veo
TAiShellExecute shell commandsWindows/Linux
TAiTextEditorToolRead/write/patch filesDiff-based editing
TAiComputerUseToolControl mouse and keyboardClaude Computer Use, OpenAI

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

⚙️ Model Capabilities — TAiCapabilities

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.

🎨 FMX Visual Components

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.

📐 Design-Time Integration

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

📦 Installation

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

Step 1 — Add Library Paths

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

Step 2 — Compile and Install Packages

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

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

Delphi Version Compatibility

Delphi VersionSupport
10.4 SydneyLimited (minimum supported)
11 AlexandriaFull support
12 AthensFull support
13 FlorenceFull support
13.1 FlorenceFull support (latest tested)

🗂️ Demo Projects

Open Demos/DemosVersion31.groupproj to access all demos.

DemoDescription
010-MinimalchatMinimal chat with Ollama and TAiChatConnection
012-ChatAllFunctionsFull-featured multimodal chat (images, audio, streaming, tools)
012-ChatWebListChat with web-based content list
021-RAG+Postgres-UpdateDBBuild a vector RAG database with PostgreSQL/pgvector
022-1-RAG_SQLiteLightweight vector RAG with SQLite
023-RAGVQLVQL query language for semantic search
025-RAGGraphKnowledge graph RAG with GQL queries
026-RAGGraph-BasicSimplified graph RAG patterns
027-DocumentManagerDocument ingestion and management
031-MCPServerMulti-protocol MCP server (HTTP, SSE, StdIO)
032-MCP_StdIO_FileManagerFile manager exposed via MCP StdIO
032-MCPServerDataSnapMCP server using DataSnap transport
034-MCPServer_Http_FileManagerFile manager via MCP HTTP
035-MCPServerWithTAiFunctionsTAiFunctions bridge to MCP
036-MCPServerStdIO_AiFunctionStdIO MCP server with AI functions
041-GeminiVeoVideo generation with Google Veo
051-AgentDemoVisual agent graph builder and runner
052-AgentConsoleConsole-based agent execution (conditional and parallel flows)
053-DemoAgentesToolsAgents with integrated tool use
054-AgentCheckpointDBDurable agent execution: suspend/resume with TAiDatabaseCheckpointer (SQLite via FireDAC)
060-AIChatUINext-generation TAIChatView + TAIChatInput components — full multimodal demo

🔄 Changelog

v3.4 (May 2026)

  • 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

v3.3 (February 2026)

  • 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

v3.2 (January 2026)

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

v3.1 (November 2025)

  • 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)

v3.0 (October 2025)

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

v2.5 (August 2025)

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

💬 Community & Support


📜 License

MIT License — see LICENSE.txt for details.

Copyright © 2024–2026 Gustavo Enríquez — CimaMaker

Ver o original no GitHub

Bom para

Relacionados