MageTech AI ForgeEngineer AI. Build Intelligence.
Customer Demo
Engineer AI. Build Intelligence.
Build production-ready AI systems with local LLMs, RAG, MCP, intelligent agents and AI engineering infrastructure — a local-first, knowledge-true alternative to generic chatbots.
Scroll to explore · Use the sidebar to jump to any section · Works offline
Overview
MageTech AI Forge is an AI engineering and agentic systems platform. It gives developers, technical teams and businesses the infrastructure to turn their own documents and systems into grounded, secure, working AI — not just another chat window.
AI Forge is built as AI engineering and infrastructure: knowledge bases, retrieval, agents, tool orchestration and a provider gateway are first-class platform services — designed to be embedded in your products and operations, with APIs you own.
It is the foundation for future MageTech intelligent products and for your own AI applications.
Your AI infrastructure can run on your own hardware via Ollama. Models, embeddings and document processing can stay inside your perimeter — reducing dependency on external AI APIs and keeping more control over your data.
Security still depends on how you deploy and operate the platform. We never claim something is “100% secure”.
A chatbot answers from a model's general knowledge. AI Forge answers from your knowledge, grounded in your documents, cites its sources, and can act — calling tools in your systems through guarded, permissioned MCP tool bridges.
Beyond click-to-build assistants, AI Forge exposes real engineering surface area: REST APIs, OpenAPI docs, model registry, executions and observability — so AI becomes part of your architecture, run and governed like software.
Local models mean your queries and documents need not leave your environment. Lower per-call cost, better data control, offline-capable development.
Retrieval-Augmented Generation connects the model to your documents — reducing hallucination and giving every answer traceable sources.
The Model Context Protocol standardizes how AI tools talk to external systems — one protocol instead of one-off integrations.
Agents can retrieve, reason and act across tools — turning AI from an answering engine into an executor of multi-step tasks.
One provider layer (now Ollama; later OpenAI, Gemini, Anthropic) means model choice is a configuration decision, not an architectural rewrite.
Business owners, CTOs, developers, AI engineers, knowledge managers, IT teams and enterprises who need AI built on their knowledge and their rules.
Category: AI Engineering & Agentic Systems Platform. Core components: document ingestion → chunking → embeddings → semantic search → context assembly → LLM completion; an agent runtime with runs & executions; MCP server/tool management over SSE; and an LLMClient gateway resolving auto | ollama | mock providers with a 30-second availability cache and graceful degradation. Everything is multi-tenant per workspace and exposed through versioned REST APIs with OpenAPI documentation.
The Why
Most organizations face the same twelve obstacles. Generic AI fails at the answer, and hard-coded point solutions fail at the architecture.
PDFs, wikis, SOPs, manuals and chats are spread across folders, drives and tools.
Employees waste hours re-finding information the company already owns.
General-purpose chatbots have no access to your products, processes or history.
Uploading sensitive material to external AI services is risky or disallowed.
Locking core workflows to one AI vendor exposes you to price and policy swings.
Summaries, follow-ups, lookups and triage still consume team-hours daily.
CRM, ERP, helpdesk and documents don’t talk to each other — or to AI.
Teams spend months wiring models, vector stores and tooling together.
Poorly understood tools, un-audited answers and no revocation path.
Every team reinvents prompting, retrieval, rate limits and security.
Granting an AI access to systems without permissions, scoping or approval.
When an AI-induced action goes wrong, there’s no trail of what it did.
How AI Forge answers this. One platform that ingests your knowledge (RAG), runs your agents with full execution records (AgentOps), connects guarded tools (MCP), keeps models local (Ollama via the AI Gateway), isolates tenants (workspaces) and is engineered — not stitched together.
Platform
Three pillars feed one engine. Knowledge, the AI runtime and MCP tools converge on an AI Gateway that speaks to your models and your database.
Product
Eight capability areas, built as platform services. Filter by pillar — Knowledge, Runtime, Tools or Platform — and expand any card for implementation detail.
Conversational, context-aware answers streamed token-by-token, grounded in your knowledge with visible source references and full conversation history.
Create knowledge bases, upload and organize documents, process them, search across them, and attach metadata and versions for reuse.
Document ingestion → text extraction → cleaning → chunking → embeddings in PostgreSQL-adjacent vector store → semantic search → context builder → cited answer.
Create and configure agents with instructions, knowledge bases, memory and tools; run them as recorded executions with versioning and monitoring.
Every agent run yields an execution: status, steps, model used, tool calls, latency, errors, token usage and audit information — built-in observability, no separate stack.
Register MCP servers, discover their tools, enable/disable them per workspace and invoke them through a standardized, guarded JSON-RPC interface.
Tools are permissioned, scoped and audit-logged; unrestricted shell, OS or arbitrary code execution through AI tools is not permitted.
Ollama runs LLM + embedding models locally — private inference, local document processing, reduced external API dependency, lower marginal cost.
Provider abstraction so model strategy is a config toggle, not a rewrite: Ollama today, OpenAI / Gemini / Anthropic tomorrow, same application architecture.
Signed-in, role-aware, tenant-isolated: JWT access + rotating refresh tokens, Argon2id password hashing, and workspace isolation via X-Workspace-Id.
Track token usage, model inventory and sync state; multi-model registry so teams can standardize on the models that work.
Async task infrastructure via Celery + Redis for heavy jobs such as document chunking and embedding — ready to scale ingestion off the request path.
Product
From account to acting agent — the twelve-step journey, in customer-friendly language.
Sign up with email and password. Passwords are hashed with Argon2id — a memory-hard standard — and logins are rate-limited.
Your own tenant boundary. Knowledge, agents, conversations, tools and models stay isolated per workspace.
Name it, describe it, assign it to the workspace — a home for your documents.
Product docs, SOPs, handbooks, manuals, support material. PDF, TXT, Markdown, CSV accepted.
The platform extracts text and cleans it. Status is tracked per document so you always know where things stand.
Content is chunked (~800 chars) and each chunk is embedded into vectors — meaning, made machine-searchable.
Chat streams answers and shows the sources behind them.
Your question is embedded and matched against your chunks by semantic similarity — not keyword guessing.
The model composes an answer grounded in retrieved context, with citations you can verify.
Give an agent a mission: instructions, which knowledge to use, which tools to hold, what memory to keep.
Register an MCP server, discover its tools and enable the ones this agent may use.
The agent retrieves, reasons and acts — every execution captured for review and audit.
Developer path. Every step above is also accessible through REST APIs with OpenAPI docs at /docs — embed any of these capabilities in your own product.
Interactive
A guided, simulated walkthrough — the exact interaction a customer experiences. Demonstration/example
Setup — “Company Knowledge” base (simulated upload)
Service catalog, modules, features
Standard operating procedures
Policies & guidelines
Equipment & maintenance
API & integration reference
Troubleshooting & FAQs
Then an agent takes an action — tool loop
Demo disclosure. This workflow is a demonstration/example. LangGraph orchestration and the ServiceFlow business connector are planned; today’s agent runtime executes recorded runs with MCP tool calls over SSE.
Use Cases
AI Forge is industry-agnostic by design: knowledge + retrieval + agents + tools fit any sector that runs on documents and processes. Filter by industry.
Use Cases
Eight audiences, eight different wins. Every persona gets a concrete outcome, not a feature list.
Automates repetitive work, surfaces business knowledge instantly and keeps AI cost under control with local models.
Gets an architecture they can defend: tenant isolation, provider abstraction, API surface, audit trail, scaling path and private/live options.
Consumes REST APIs + OpenAPI docs, builds on MCP, configures agents and rides on a gateway that hides provider SDK churn.
Controls models, embeddings, retrieval quality and agent workflows; evaluates and inspects executions via AgentOps telemetry.
Owns the knowledge bases: uploads, organizes, version-rolls documents and watches retrieval quality improve.
Automates follow-ups, lookups and reporting through agents — cutting manual ticking and chasing.
Runs it in Docker Compose, controls access, isolates tenants and owns governance (RBAC enforcement arriving in MVP-3).
Plans an internal AI platform: private/local AI, business integrations (planned), OAuth2 connectors (planned), audit + compliance posture.
Technology
A pragmatic, modern stack — battle-tested building blocks chosen for control, privacy and developer velocity. Browse each tier, then open the technical view.
App Router, SSR/streaming, module pages for chat, agents, knowledge, MCP, models, usage and executions.
Design-system components (button, card, badge, avatar) built on class-variance-authority and tailwind-merge. TypeScript, TanStack Query, Zod 4.
Async API with REST under /api/v1 and OpenAPI docs at /docs. Pydantic 2, SQLAlchemy 2 async + asyncpg.
Auth, chat, knowledge, agents, MCP, models, usage, execution, dashboard. Versioned, typed, rate-limited.
Local inference for generation (qwen2.5:7b) and embeddings (nomic-embed-text). Model registry with sync & pull.
Provider abstraction auto|ollama|mock, availability cache, deterministic mock for dev/CI, token accounting.
Stateful agent graphs (state machine, checkpoints) for Phase 4 orchestration.
Indexing/retrieval orchestration for advanced document intelligence (Phase 4).
Async SQLAlchemy + Alembic migrations; pgvector extension provisioned; pg_dump-ready backups.
Rate-limit storage, Celery broker + result backend, application cache (DB 0 app / DB 1 celery).
Async jobs (e.g., document chunking/embedding) ready off the request path. Deliberately opt-in (use_celery=false) so single-node setups run inline with no extra machinery.
JWT access (15 min) + refresh (7 days, HttpOnly cookie), Argon2id password hashing, PyJWT.
slowapi rate limits (auth 10/min, default 200/min), CORS allowlist, secure headers, input + file validation.
Workspace isolation via X-Workspace-Id; role model defined; RBAC enforcement is the planned MVP-3 milestone.
Execution records, usage analytics, /api/v1/health (incl. vector-search & MCP component status), request IDs, audit entries.
| Frontend | Next.js 16.3.5 · React 19.2.8 · TypeScript · Tailwind CSS v4 · shadcn-style UI · TanStack Query · Zod — progressive, typed, streaming-ready. |
| Backend | Python ≥3.12 · FastAPI · Pydantic 2 · SQLAlchemy 2 (async) · Alembic · httpx — async-first REST + SSE under /api/v1. |
| AI | Ollama (qwen2.5:7b, nomic-embed-text) · LLMClient AI Gateway · LangGraph & LlamaIndex planned · MCP over SSE. |
| Database | PostgreSQL 16 with pgvector extension provisioned · Redis 7 · pg_dump/WAL-ready backups. |
| Processing | Celery (opt-in) + Redis broker for document processing tasks. |
| Infrastructure | Docker + Docker Compose (postgres, redis, ollama, backend, worker, frontend) — single-command environment. |
| Security | JWT + refresh tokens · Argon2id · RBAC (roles defined; enforcement planned) · rate limiting · CORS · secure headers · audit logging · input/file validation · prompt-injection protections. |
Deployment. The whole platform runs with docker compose up from infrastructure/docker — Postgres, Redis, Ollama, API, worker and frontend — the same footprint from laptop to VPS to private cloud.
Technology
How a raw document becomes a grounded, cited answer — every stage animated below.
Documents are parsed, cleaned and chunked (~800 chars, 160 overlap) so each chunk is self-contained and searchable.
Every chunk becomes a 384-dim vector capturing meaning — enabling semantic (not keyword) matching.
Your question is embedded, ranked against stored vectors, and the best context is assembled for the model — with sources.
Technology
An agent turns a request into a traced sequence: state, retrieval, tool use, result — then a final response. Execution metadata only; no hidden chain-of-thought is exposed.
Each run carries its own state: instructions, retrieved context, tool state and memory of prior turns.
Tool calls are permissioned and recorded; failures surface as safe error metadata, not raw stack traces.
Tools are enable/disable per workspace; high-risk actions and audits are tracked; no free-form code execution.
Safety & transparency. We deliberately do not expose hidden chain-of-thought. Observability shows what the agent did — state, tool calls, results, latency, model, tokens, errors — which is what you can audit.
Technology
The Model Context Protocol gives AI systems a standard, secure way to interact with tools and external systems — one protocol instead of one-off integrations.
A sample tool registry your MCP servers could expose:
POST /api/v1/mcp/tools/call HTTP/1.1
X-Workspace-Id: ws_demo
{ "name": "get_due_services",
"arguments": { "window_days": 7 } }Technology
Security is designed in, not bolted on. Each control below protects real outcomes for your business.
Email + password with JWT access tokens (15 min) and rotating refresh tokens (7 days) in an HttpOnly, SameSite=Lax cookie scoped to the refresh path.
Argon2id — a memory-hard hashing standard that resists GPU brute-forcing.
Workspaces partition knowledge, agents, conversations, tools and models. Every entity is workspace-scoped; the X-Workspace-Id header selects the tenant.
Role model with rank ordering is defined. Route-level RBAC enforcement is the next milestone — today, protection is workspace ownership + per-object guards.
Token-bucket limiting per client key: auth 10/min, default 200/min — powered by Redis with in-memory fallback.
Secure headers, CORS allowlist, input & file validation on uploads — sizing limits bound ingestion cost and abuse surface.
Documents are treated as untrusted data; build-time and run-time controls reduce prompt-injection risk, with documented residual risk.
MCP tools are enable/disable per workspace; high-risk & external actions are audited; no shell/OS/arbitrary code execution is permitted.
Executions, tool calls, usage and system events are recorded — a trail of what the AI did, when, and why.
TLS at the proxy; secrets via env/config validation (validate_production() enforces rotated secrets); secrets never placed in model prompts.
Postgres-native backups (pg_dump/WAL) with restore drills in the production checklist; Alembic migrations for versioned schema.
Planned: refresh-token blacklist, settings system, SSO/OAuth2 connectors and expanded RBAC surface.
Customer benefit. You get identity, isolation and audit built in — so AI features meet the same standard you already hold your other systems to, without a separate security project.
Technology
The entire AI stack can run on your hardware. That changes what “sending data to the cloud” means — for the better.
Generation and embedding models run in-process with your infrastructure — no third-party inference service required.
Documents are embedded on-site (nomic-embed-text, 384-d), so raw content never needs to leave your perimeter to be searched.
Parsing, chunking and quality control happen in your environment, with your policies.
Fewer external AI calls means lower per-token exposure, steadier cost and tolerance to vendor outages.
The AI Gateway keeps the door open to managed providers (OpenAI, Gemini, Anthropic) — planned — while local models remain the default.
Keep knowledge, analytics and audit records inside your estate, aligned with internal and regulatory expectations.
Honest framing. Local-first reduces external dependency and improves data control, but it is not a guarantee of absolute privacy or security. Actual protection depends on how you deploy, configure and operate the platform.
Technology
Integrations are tiered by reality. Green is running today, blue is under build, purple is future direction — nothing is implied production-ready before it exists.
Primary relational store.
Vector extension provisioned; native columns planned.
Rate limits, queues, caching.
Local models + embeddings.
Tool protocol over SSE.
Plugs into the AI Gateway behind LLMClient.
Plugs into the AI Gateway behind LLMClient.
Plugs into the AI Gateway behind LLMClient.
Outbound event delivery into your systems.
Two-legged connector credentials for business APIs.
Customers / equipment / jobs / technicians bridge.
Customer & order context for agents.
Ticketing context + auto-triage.
Any reachable HTTP API, exposed as guarded MCP tools.
Business
How AI Forge can eventually power intelligent features inside MageTech ServiceFlow. Demonstration scenario
Tap a question to preview a simulated answer
Demo disclosure. These questions and answers are demonstration scenarios. The ServiceFlow connector is future direction; the underlying agent + MCP runtime for such flows is what exists today.
Business
Value you can defend in a board meeting — no invented statistics. Where illustrative targets appear, they are clearly labeled.
Seconds to find the right answer, with sources, instead of hours of digging. (Illustrative target: lookup time in minutes → seconds.)
Summaries, follow-ups, status checks and triage move from human keystrokes to agents with audit trails.
Teams stop re-answering the same questions and re-finding the same documents.
Faster, consistent, knowledge-backed answers for customers and internal support staff.
Operational agents (follow-ups, due checks, summaries) run in the background, on schedule.
One governed home for institutional knowledge — searchable, versioned, attributed.
Local models keep core value flowing even when external APIs are down or repriced.
APIs, OpenAPI docs and MCP tooling mean teams build on the platform, not rewire it.
An internal AI platform that grows from knowledge assistant to full agentic automation.
Metrics policy. This document does not fabricate outcomes. Quantified benefits you see anywhere are labeled example or target; real numbers come from measuring your deployment.
Pricing
We price AI Forge as an AI engineering & agentic platform — not a chatbot. Local LLM inference is included when you run with your own infrastructure; third-party model costs are billed separately by the respective provider. Prices are indicative USD list prices.
Monthly billing · convert to annual for 2 months free on paid plans.
For developers, students, experimentation and POCs.
For individual developers and AI builders.
For teams building internal AI applications together.
For companies building internal AI applications and business agents at scale.
For larger organizations requiring private AI infrastructure and full control.
AI model usage. Local LLM inference is included when you run MageTech AI Forge with your own infrastructure (Ollama). Third-party model/API costs are billed separately by the respective provider — we do not bundle or inflate cloud inference into platform pricing.
| Feature | Community | Developer | Team | Business | Enterprise |
|---|---|---|---|---|---|
| Monthly | $0 | $29 | $99 ⭐ | $249 | Custom |
| Users | 1 | 3 | 10 | 25 | Unlimited |
| Projects | 1 | 5 | 20 | Unlimited | Unlimited |
| Knowledge bases | 1 | Unlimited | Unlimited | Unlimited | Unlimited |
| Agents | 3 | 25 | Unlimited | Unlimited | Unlimited |
| MCP tools | 3 | 25 | Unlimited | Unlimited | Unlimited |
| RAG | Basic | Advanced | Advanced | Advanced | Custom |
| AgentOps | Basic | Basic | Advanced | Advanced | Enterprise |
| Memory | Basic | Yes | Yes | Yes | Yes |
| API access | — | Yes | Yes | Yes | Yes |
| RBAC | — | Basic | Yes | Advanced | Enterprise |
| SSO | — | — | — | Yes | Yes |
| Audit logs | — | — | Yes | Yes | Yes |
| Private deployment | Yes | Yes | Yes | Yes | Yes |
| On-premise | — | — | — | — | Yes |
| Support | Community | Priority | Priority | Dedicated |
A clean progression: Free → Developer → Team → Business → Enterprise. Free for POCs, Team is the sweet spot for most teams, Business adds SSO and scale, Enterprise is fully private and on-premise. We keep the public tier structure simple and add self-hosted licensing separately.
Self-hosting
Because self-hosting is core to AI Forge, we separate the software license from your infrastructure. You bring the hardware (GPU/CPU, PostgreSQL, Redis, Ollama or local models, storage, networking); we provide the software and support.
| Edition | Price | What you get |
|---|---|---|
| Community | Free | Self-hosted Docker, Community support |
| Developer License | $299 / year | Email support, commercial use |
| Team License | $999 / year | Priority support, MCP allowlists, audit logs |
| Business License | $2,499 / year | SSO, advanced RBAC, deployment assistance |
| Enterprise | Custom | On-prem, SLA, dedicated support, security reviews |
MageTech provides the AI Forge software and support under the license; you own and operate your infrastructure.
India
Localized pricing for the Indian market. USD remains the primary international price; INR is an approximate regional equivalent.
| Plan | USD | Approx. INR |
|---|---|---|
| Community | $0 | ₹0 |
| Developer | $29 / mo | ₹2,499 / mo |
| Team | $99 / mo | ₹8,499 / mo |
| Business | $249 / mo | ₹20,999 / mo |
| Enterprise | Custom | Custom |
India pricing shown is indicative and subject to confirmation. Annual billing applies where noted.
Why separate pricing? It keeps economics safe: local inference is included on your own infrastructure, cloud inference is metered by the provider, and the software license is priced like the AI infrastructure market — open core at the base, enterprise capabilities and support sold separately.
Business
AI Forge against the alternatives — generic chatbots and one-off AI features. Scroll horizontally on small screens.
| Capability | Chatbot | No-code Builder | AI Forge |
|---|---|---|---|
| AI Chat | ✅ | ✅ | ✅ |
| Knowledge Bases | — | ⚠️ limited | ✅ |
| RAG with citations | — | ⚠️ | ✅ |
| Local LLM (Ollama) | — | — | ✅ |
| Agents + executions | — | ✅ | ✅ |
| MCP tool protocol | — | ⚠️ | ✅ |
| AI Gateway (proxy) | — | — | ✅ |
| Memory | ⚠️ | ⚠️ | ✅ |
| AgentOps (observability) | — | ⚠️ | ✅ |
| API access + OpenAPI | — | ⚠️ | ✅ |
| Integrations (SSE/HTTP) | — | ⚠️ | ✅ MCP |
| RBAC | — | — | 🔵 planned |
| Audit logs | — | ⚠️ | ✅ |
| Advanced security | — | ⚠️ | ✅** |
| Enterprise support | — | ⚠️ | 🧩 planned |
✅ = available · ⚠️ = partial · 🔵 = roadmap · 🧩 = planned tier. ** Advanced security = tenant isolation, rate limits, validation, tool permissions, audit, prompt-injection controls (advanced RBAC is roadmap).
Interactive
Five complete customer demos — problem, setup, workflow, interaction, expected result, business value and architecture. Simulated examples
Teams can’t find answers buried in product and policy documents.
One knowledge base, product docs uploaded.
Upload → process → embed → ask → cited answer.
“How do I enable SSO?” → answer with sources.
Instant, accurate, source-backed answers.
Faster onboarding, self-service support, single source of truth.
RAG pipeline: parse → chunk (800/160) → embed (384-d) → semantic search → context → LLM.
Support tickets repeat the same troubleshooting steps.
Knowledge base + a support agent with tool access.
Knowledge → agent → troubleshoot → response with steps.
“VPN connects but pages time out” → diagnostic path + fix.
First-line resolution with documented steps and citations.
Lower ticket time, consistent answers, measurable CSAT.
Agent runtime + RAG retrieval + recorded execution.
Service teams chase due jobs and follow-ups by hand.
ServiceFlow business data + MCP tool bridge (future) + agent.
Customer data → MCP → agent → service information/action.
“Show overdue service jobs and draft follow-up messages.”
List + drafted follow-ups with audit trail.
Automated follow-ups, fewer missed renewals.
Agent + MCP tools over SSE → business API. ServiceFlow connector is future direction.
Research across scattered knowledge is slow and uncited.
Research knowledge base + tool-using agent.
Knowledge + tools → research workflow → summarized result.
“Compare our three pricing plans’ coverage options.”
Structured comparison with per-fact sources.
Analyst-grade summaries in minutes, not days.
RAG + multi-tool agent; LangGraph graphs and LlamaIndex orchestration are roadmap.
Employees need private internal answers without sending data to external AI.
Company documents → private/local AI (Ollama) → employee assistant.
SSO-style access → ask → grounded, private answers.
“What’s our remote-work policy on equipment?”
Policy-accurate answers staying fully in-perimeter.
Data-stays-home AI for regulated or conservative environments.
Local Ollama + RAG in Docker Compose; tenant isolation; RBAC/SSO at Enterprise tier (roadmap).
Try Demo 1 live. Open the simulated chat to feel the streaming + citation experience in context.
Business
A pragmatic path from knowledge to enterprise automation. Status markers separate what exists today from what is planned.
Ingestion, chunking, embeddings, semantic search, cited chat.
AvailableServer/tool management, permissioned calls over SSE.
AvailableAgents, runs, executions, usage analytics, model registry.
AvailableLangGraph stateful graphs, LlamaIndex orchestration, richer trace dashboards (usage analytics live today).
PlannedRBAC enforcement, refresh blacklist, settings system.
PlannedWebhooks, OAuth2 connectors, ServiceFlow/CRM/ERP bridges, managed AI providers.
Future directionMulti-tenant workspaces, RAG chat with citations, agents + executions, MCP tools, Ollama + AI Gateway, usage analytics, rate limits, OpenAPI APIs.
RBAC enforcement, refresh-token blacklist, settings, native pgvector column store + ANN indexing, webhooks, OAuth2 connectors.
LangGraph + LlamaIndex orchestration, MCP SDK companion, managed AI providers (OpenAI/Gemini/Anthropic), packaged business integrations.
Resources
Straight answers to the questions customers actually ask.
An AI engineering and agentic systems platform — local-first infrastructure for building RAG knowledge systems, MCP tools, intelligent agents and AI-powered automation, plus the AI Gateway and AgentOps to run it in production.
Developers, technical teams, business owners, CTOs, knowledge managers and enterprises — anyone who needs AI grounded in their own knowledge and connected to their systems.
No — it is an engineering platform. Chat is one module; the value is the knowledge, agents, tools, gateway and APIs underneath it.
Retrieval-Augmented Generation: the model retrieves your relevant document chunks first, then composes an answer grounded in them, with sources you can verify.
The Model Context Protocol — a standard way for AI systems to securely interact with tools and external systems through a single, permissioned interface.
Yes. Ollama runs generation (qwen2.5:7b) and embedding (nomic-embed-text) models locally — private inference without third-party APIs.
No. With local models it runs free of per-token API fees. Paid managed providers (OpenAI, Gemini, Anthropic) are future gateway options if you choose them.
Yes — that is the core model. You create knowledge bases and upload PDF, TXT, Markdown and CSV; the platform turns them into searchable, citable knowledge.
Through MCP servers and tools today for tool-driven access; packaged connectors (webhooks, OAuth2, ServiceFlow, CRM/ERP) are planned/future.
Yes — workspaces isolate knowledge, agents, conversations, tools and models per tenant, selected via the X-Workspace-Id header.
Yes. Versioned REST APIs under /api/v1 with OpenAPI docs at /docs — chat, knowledge, agents, MCP, models, usage and execution endpoints.
Yes — Docker Compose deploys everything (Postgres, Redis, Ollama, API, worker, frontend) on your own hardware or cloud.
JWT auth + rotating refresh tokens, Argon2id, tenant isolation, rate limiting, CORS + secure headers, validation, tool permissions, prompt-injection controls and audit logging. RBAC enforcement is roadmap.
The architecture is designed for it (agents + MCP → business data). The ServiceFlow connector itself is future direction and shown only as a demonstration scenario.
Any Ollama-served model today (defaults qwen2.5:7b + nomic-embed-text). Managed providers become gateway options in the future.
The architecture separates services (API, worker, DB, Redis) for horizontal scaling and Celery offloads heavy processing — with an opt-in switch today and enterprise hardening on the roadmap.
Usage analytics track token counts and model usage; AgentOps records every execution — status, steps, tool calls, latency, errors and model — plus workspace-level accounting.
Resources
The vocabulary you’ll hear, translated.
Large Language Model — a neural network trained to generate human-like text from context.
An LLM served on your own hardware (e.g., via Ollama) instead of a third-party API.
Retrieval-Augmented Generation: grounding answers in retrieved knowledge with citations.
Dense numeric vectors that capture the meaning of text for similarity search.
A store optimized for similarity search over embeddings.
PostgreSQL extension adding vector columns and ANN indexing.
Model Context Protocol — standardized AI↔tool communication over JSON-RPC/SSE.
A system that retrieves, reasons and acts across tools to complete tasks.
The layer that executes agents and records every run.
Library for stateful, graph-based agent orchestration (planned here).
Library for indexing/retrieval orchestration (planned here).
Local model server running open LLMs and embeddings on your machine.
Abstraction layer (LLMClient) that isolates the platform from provider SDKs.
Observability for agents: executions, steps, model, tools, latency, tokens, errors, audit.
Meaning-based retrieval over embeddings (vs literal keyword matching).
Model structured requests to invoke registered tools — permissioned and logged.
Attempts to override an AI’s instructions via untrusted input; mitigated with control layers.
One platform serving many isolated tenants (workspaces here).
Role-based access control: permissions by role (enforcement is roadmap here).
Getting Started
Eight steps from “hello” to a working AI feature.
Walk the platform with MageTech.
Pick the problem and success measure.
Upload the documents and KBs.
Choose local models via the AI Gateway.
Instructions, memory, grounding.
Register MCP servers, enable tools.
Run executions and review agent ops.
Ship on Docker Compose, yours or ours.
# Self-host the whole platform on your own hardware git clone https://github.com/magetech-solutions/aiforge.git cd aiforge docker compose -f infrastructure/docker/docker-compose.yml up -d # API + OpenAPI docs live here once up # API: http://localhost:8000/api/v1/health # Docs: http://localhost:8000/docs
# 1) Register and get tokens
curl -X POST http://localhost:8000/api/v1/auth/register \
-H "Content-Type: application/json" \
-d '{"email":"demo@mage.tech","password":"ChangeMe#2026"}'
# 2) Upload a document to your knowledge base
curl -X POST http://localhost:8000/api/v1/knowledge/documents \
-H "Authorization: Bearer $TOKEN" \
-F "knowledge_base_id=YOUR_KB" -F "file=@service-manual.pdf"
# 3) Ask a grounded question (streaming)
curl -N -X POST http://localhost:8000/api/v1/chat/stream \
-H "Authorization: Bearer $TOKEN" \
-H "Content-Type: application/json" \
-d '{"message":"What is MageTech ServiceFlow?"}'
Company
MageTech Solutions builds the intelligent products behind this demo. MageTech AI Forge is the AI engineering platform in the family — the foundation that powers knowledge, agents and automation.
“Engineer AI. Build Intelligence.”
This section describes the organization and its product family at a high level. It intentionally contains no invented statistics, certifications, customers or achievements.
The relationship above is an organization-level illustration. Product details of sibling products are outside the scope of this document.
This chat is a demonstration of the streaming + citation experience · powered by the real product API in a live deployment.
Next steps to see AI Forge for your use case.
Bring 3–5 of your real documents and one business question.
Local (Ollama + Docker Compose) or guided cloud pilot.
Your MageTech representative or our repository README points to the quickstart.
Demo sessions are scheduled through MageTech Solutions. No statistics, prices or roadmaps are locked by a demo.
Copy the commands, run them locally, and you’re up.
git clone https://github.com/magetech-solutions/aiforge.git cd aiforge docker compose -f infrastructure/docker/docker-compose.yml up -d # API: http://localhost:8000/api/v1/health # Docs: http://localhost:8000/docs # Web: http://localhost:3000