Skip to content

Knowledge Platform Overview

Target Architecture — Final-State Design

This page describes the final-state target architecture of the Knowledge Platform. Where a capability is already implemented in the codebase it is marked separately; everything else is the designed end state the factory converges to.

The Knowledge Platform — canonically named Knowledge Platform, also referred to as the Knowledge Fabric — is the long-term memory and reasoning substrate of the ConnectSoft AI Software Factory. It is not a chatbot, a search box, or a retrieval add-on. It is the AI-native memory backbone that grounds every autonomous agent in the factory's accumulated knowledge: prior architectural decisions, reusable patterns and templates, indexed code, generated artifacts, documentation, and the runtime behaviour of everything the factory has ever shipped.

Where the Agent Mesh supplies reasoning and the Control Plane supplies orchestration, the Knowledge Platform supplies grounded memory. Every agent task is preceded by a governed Context Package assembled here, and every artifact, event, and runtime signal the factory produces flows back in to enrich that memory. This is what turns the factory from a stateless code generator into a system that learns — accumulating reusable knowledge with every project so that each new SaaS product is cheaper, faster, and higher quality than the last.

Purpose

The platform exists to make the factory traceable, reusable, and self-improving at scale:

  • Ground autonomous agents. No agent reasons from parametric model memory alone. Each task consumes a Context Package containing the relevant decisions, code, patterns, and feedback for this tenant, project, and module.
  • Capture everything the factory learns. Every artifact produced, decision made, prompt run, and runtime signal observed becomes a durable, queryable memory record.
  • Make knowledge reusable across projects. Patterns, templates, blueprints, and decisions discovered on one project are surfaced as candidate reuse on the next — across the multi-tenant estate, subject to governance.
  • Close the improvement loop. Runtime feedback from the Observability & Feedback Platform is attributed back to the exact context, prompt, and decision that produced an artifact, so the factory can measure and improve outcomes.

Role in the AI Software Factory

flowchart LR
    Intent["Business Intent"] --> CP["Control Plane"]
    CP -->|assign task| AM["Agent Mesh"]
    AM -->|"BuildContextPackage"| KP["Knowledge Platform"]
    KP -->|"governed ContextPackage"| AM
    AM -->|artifacts + events| KP
    AM -->|artifacts| TL["Template & Library Platform"]
    OBS["Observability & Feedback"] -->|runtime signals| KP
    TL -->|patterns + templates| KP
    KP -->|reuse candidates| AM
Hold "Alt" / "Option" to enable pan & zoom

The Knowledge Platform sits at the centre of the factory's information flow. It is a read-and-write participant in the lifecycle: it serves context into agent execution, and it ingests artifacts, events, and signals out of execution and runtime. Every interaction is correlated by the canonical event envelope traceId, so a single trace links business intent → blueprint → agent task → context package → generated artifact → commit → deployment → runtime signal → feedback.

Core Responsibilities

Responsibility Description
Knowledge graph Maintain the typed graph of tenants, projects, blueprints, modules, artifacts, contracts, events, agents, skills, commits, deployments, and runtime signals, with the relationships between them.
Vector & semantic memory Embed and index artifacts, code, documentation, and patterns for semantic and hybrid retrieval.
Artifact memory Store full artifact bodies, versions, and snapshots with content-addressable lineage.
Code knowledge Index repositories, extract symbols, and build code dependency graphs for code-aware retrieval.
Documentation knowledge Ingest and chunk documentation sites and design docs for grounding.
Prompt & decision memory Capture prompt templates, prompt runs, and architectural decision records with their alternatives.
Runtime memory & feedback Ingest runtime signals, incidents, and feedback items and make them replayable.
Pattern catalog Promote recurring solutions into reusable, versioned knowledge patterns.
Context building Assemble governed, budgeted Context Packages on demand for agent tasks.
Knowledge governance Enforce access policy, classification, redaction, and quality on all memory.
Ingestion Normalise, chunk, embed, classify, and graph-project every incoming artifact and signal.

Key Capabilities

  • Governed context assembly — the ContextBuilderService fuses graph, vector, and metadata retrieval into a single ranked, access-checked, token-budgeted package.
  • Hybrid retrieval — combined dense-vector and structured-metadata search, fused and re-ranked, with graph-neighbourhood expansion.
  • Source-controlled memory — durable knowledge (decisions, patterns, prompts) is versioned in Azure DevOps Git so memory itself is reviewable and auditable.
  • Multi-tenant isolation — tenantId is an isolation boundary in every store, index, and policy decision.
  • Full traceability — every memory record, context source, and access decision is correlated by traceId and audited.
  • Self-improving loop — runtime signals and feedback are attributed back to producing context for continuous quality improvement.

High-Level Component Diagram

flowchart TB
    subgraph Contexts["Bounded Contexts"]
        KG["Knowledge Graph"]
        VM["Vector & Semantic Memory"]
        AMem["Artifact Memory"]
        CK["Code Knowledge"]
        DK["Documentation Knowledge"]
        PD["Prompt & Decision Memory"]
        RM["Runtime Memory & Feedback"]
        PC["Pattern Catalog"]
        CB["Context Building"]
        ING["Ingestion"]
        GOV["Knowledge Governance"]
    end

    subgraph Stores["Persistence"]
        SQL[("PostgreSQL / Azure SQL<br/>metadata + graph")]
        Qdrant[("Qdrant<br/>vectors")]
        Blob[("Azure Blob<br/>artifacts")]
        Git[("Azure DevOps Git<br/>source-controlled memory")]
        Redis[("Redis<br/>hot context packages")]
        OTEL[("App Insights / OTEL<br/>runtime telemetry")]
    end

    ING --> KG
    ING --> VM
    ING --> AMem
    CK --> KG
    DK --> VM
    PD --> KG
    RM --> KG
    PC --> KG
    CB --> KG
    CB --> VM
    CB --> GOV
    CB --> Redis

    KG --> SQL
    VM --> Qdrant
    AMem --> Blob
    PD --> Git
    PC --> Git
    RM --> OTEL
    GOV --> SQL
Hold "Alt" / "Option" to enable pan & zoom

Integration with Other Platforms

flowchart LR
    AM["Agent Mesh"] -->|context requests| KP["Knowledge Platform"]
    KP -->|context packages, reuse| AM
    CP["Control Plane"] -->|lifecycle events| KP
    TL["Template &amp; Library Platform"] -->|templates, patterns, libraries| KP
    KP -->|pattern discoveries| TL
    OBS["Observability &amp; Feedback"] -->|runtime signals, incidents, feedback| KP
    KP -->|quality + lineage| OBS
    GOV["Governance, Security &amp; Compliance"] -->|policy, classification rules| KP
    KP -->|access audits| GOV
Hold "Alt" / "Option" to enable pan & zoom
Platform Knowledge Platform receives Knowledge Platform provides
Agent Mesh Context build requests, produced artifacts Governed Context Packages, reuse candidates
Control Plane Workflow and lifecycle events Knowledge availability for task gating
Template & Library Platform Templates, libraries, reusable modules Discovered patterns, usage signals
Observability & Feedback Runtime signals, incidents, feedback items Context-to-outcome attribution, lineage
Governance, Security & Compliance Access policies, classification taxonomy Memory access decisions and audits

Implemented Foundations

Implemented

The conceptual and indexing foundations of this platform are already documented and partially realised in the codebase. See the existing implementation references:

The final-state platform builds on these with the full microservice, worker, and governance topology described across this section.

Final-State Summary

The Knowledge Platform is the durable, governed, multi-tenant memory of the AI Software Factory. In its final state it comprises 22 microservices, 20 background workers, 32 aggregate roots, and 14 public APIs organised into eleven bounded contexts, persisting across PostgreSQL/Azure SQL, Qdrant, Azure Blob, Azure DevOps Git, Redis, and an OTEL telemetry backend. It transforms the factory from a stateless generator into a learning system: every artifact, decision, and runtime signal becomes reusable, traceable knowledge, and every agent task is grounded in a governed context package assembled from that knowledge.