Integration

AI Integration for OpenText Core

Add AI-powered content services to OpenText Core SaaS for mid-market teams, enabling smart filing, collaborative drafting, and project content intelligence.

Get in touch Learn more

Wide-angle shot of a modern WeWork open floor plan with creative walls covered in AI system architecture diagrams, product team collaborating in standing desk area with industrial lighting.

ARCHITECTURE AND ROLLOUT

Where AI Fits into OpenText Core

A practical guide to integrating AI into OpenText Core's content services, collaboration, and project workflows.

AI connects to OpenText Core through its REST API and event webhooks, acting on three primary surfaces: the Content Repository for documents and files, the Collaboration Workspaces for team projects, and the Metadata and Taxonomy layer for governance. The integration typically sits as a middleware service that listens for events like file.uploaded or project.created, processes the content or context using an LLM, and writes results back via API—enriching metadata, suggesting folder structures, or drafting collaborative summaries without altering Core's native user experience.

For rollout, start with a single, high-value workflow such as automated project folder setup. When a new project workspace is created in Core, an AI agent can analyze the project name, description, and member list to:

Generate a recommended folder structure (e.g., Proposals, Meeting Notes, Deliverables).
Draft a starter project charter based on template libraries.
Tag the workspace with relevant metadata from your corporate taxonomy. This moves project setup from a 30-minute manual task to a consistent, seconds-long automated process, giving teams a head start with structured content.

Governance is managed through API key scopes and audit trail integration. The AI service should use a dedicated service account with write permissions only to specific areas (e.g., a Sandbox workspace) during piloting. All AI-generated content and metadata suggestions should be logged with a source: ai_assist flag in Core's native version history. For sensitive documents, implement a human-in-the-loop approval step where AI suggestions appear as pending tasks in Core's task management module, requiring a user's review before application. This balances automation with control, ensuring AI acts as a copilot, not an autonomous actor.

This architecture matters because it makes Core smarter, not different. Teams continue using the familiar Core interface for document management and collaboration, but benefit from AI reducing manual overhead in filing, tagging, and drafting. The integration turns Core from a passive repository into an active participant in content workflows, helping mid-market teams achieve enterprise-grade content intelligence without complex migration or user retraining. For a deeper technical blueprint, see our guide on AI Integration for Intelligent Document Processing in ECM Platforms.

AI-POWERED CONTENT SERVICES

Key Integration Surfaces in OpenText Core

Automate Filing and Metadata

Integrate AI at the point of upload—via email ingestion, mobile capture, or desktop sync—to instantly classify documents and apply rich metadata. This transforms manual filing into a zero-touch operation.

Key Workflows:

Smart Inbox: Route incoming invoices, contracts, and support tickets to correct project folders based on content analysis.
Auto-Tagging: Use LLMs to read document text and assign tags from your Core taxonomy (e.g., Project-Phase, Document-Type, Confidentiality-Level).
Duplicate Detection: Identify near-identical versions of proposals or reports to prevent repository bloat.

Implementation: Deploy serverless functions triggered by Core's webhooks. The function calls your AI model, returns structured JSON with classification results, and uses the Core REST API to update the document's metadata and location.

SMART CONTENT SERVICES FOR MID-MARKET TEAMS

High-Value AI Use Cases for OpenText Core

Integrate AI directly into OpenText Core's collaborative SaaS environment to automate content-centric workflows, accelerate project delivery, and unlock insights from unstructured documents. These patterns connect LLMs to Core's APIs, folders, and metadata to deliver practical, immediate value.

Smart Filing & Auto-Classification

Use AI to analyze uploaded documents (contracts, proposals, specs) and automatically assign metadata, apply tags, and file them into the correct Core project folder based on content. Workflow: File upload triggers an AI service via webhook, which reads the document, extracts key entities (client name, project ID, document type), and uses the Core REST API to update metadata and move the file.

Manual → Automated

Filing process

Collaborative Drafting Assistant

Embed an AI copilot within Core's document editor or via a sidebar panel to help teams draft, summarize, and refine project content. Workflow: Users select text in a Core document and trigger an AI action (e.g., 'Summarize this section', 'Suggest improvements', 'Check for compliance language'). The AI returns suggestions that can be accepted or edited in-place, keeping all work within Core's version history.

Hours -> Minutes

Review cycles

Project Content Intelligence

Build a RAG-powered Q&A interface over a Core project's entire document library. Workflow: Index all documents in a Core project space (specs, meeting notes, emails, designs) into a vector store. Team members ask natural language questions ('What are the open items from the last client review?', 'What's the agreed spec for module X?') and get answers sourced and cited from the project's content, without manual searching.

Search → Answers

Knowledge access

Automated Meeting Note Synthesis

Connect Core to meeting platforms (Zoom, Teams) to automatically generate and file structured notes. Workflow: After a meeting, the transcript is sent to an AI service, which generates a summary, extracts action items and decisions, and creates a formatted document in a designated Core folder. The AI uses Core's API to tag the document with participant names, project ID, and date.

1 sprint

Implementation time

Compliance & Policy Check

Automatically screen project documents for compliance with internal policies or regulatory requirements. Workflow: Configure AI to scan new or updated documents in specific Core folders for red-flag language, missing clauses, or sensitive data (PII). Findings are logged as Core metadata, and non-compliant documents can be automatically routed to a review queue or trigger an alert to the project manager.

Batch → Real-time

Compliance review

Intelligent Content Recommendations

Surface relevant, related documents to users as they work, based on semantic similarity. Workflow: As a user views a document in Core, a background service queries the vector index for semantically similar files (past proposals, similar specs, related contracts) and displays them in a 'Recommended' panel. This connects disparate content across projects and reduces duplicate work.

Same day

Discovery time

OPENAI INTEGRATION FOR OPENTEXT CORE

Example AI-Powered Workflows

These workflows demonstrate how to connect LLMs and AI agents to OpenText Core's content services, APIs, and user interfaces to automate collaborative tasks, enhance content intelligence, and accelerate project delivery.

Trigger: A new file is uploaded to a shared project folder in OpenText Core.

Context Pulled: The integration service listens for the file.created webhook from Core. It retrieves the file's binary content and metadata (uploader, folder path, project ID).

AI Action: The file is sent to a multi-modal LLM (e.g., GPT-4 Vision) for analysis. The model classifies the document type (e.g., contract, specification, meeting_minutes, wireframe) and extracts key entities (project names, dates, responsible parties).

System Update: Based on the classification, the system:

Applies a corresponding metadata profile in Core (e.g., sets Document Type, Project Phase).
Automatically moves the file to a designated sub-folder (/Contracts/, /Design/).
Creates a task in the linked project management tool (e.g., Asana, Monday.com) if the file is a deliverable.

Human Review Point: Low-confidence classifications or files containing potential PII are flagged for review in a dedicated Core workspace, notifying the project manager.

FROM CAPTURE TO INSIGHT

Implementation Architecture & Data Flow

A secure, event-driven architecture to add AI-powered content services to OpenText Core without disrupting existing user workflows.

The integration connects at the OpenText Core REST API layer, typically triggered by webhooks for events like document.created, document.updated, or folder.moved. For each new or modified file, the system extracts the binary content and existing metadata, then routes it through a serverless processing pipeline. This pipeline first uses Core's native classification or a lightweight AI model to determine the document's domain (e.g., project_proposal, meeting_minutes, vendor_contract), which dictates the subsequent AI workflow—such as smart filing suggestions, collaborative drafting support, or project intelligence extraction.

For smart filing, the AI analyzes the document's content and context (user, project, keywords) to recommend the most relevant Core folder, applying suggested metadata tags from your enterprise taxonomy. For collaborative drafting, the integration can be invoked via a custom action in the Core UI, sending the draft document to an LLM for summarization, tone adjustment, or clause suggestion, with changes returned as tracked suggestions. Project content intelligence workflows run on a schedule, analyzing all documents within a designated Core project space to generate a weekly digest of key decisions, action items, and open risks.

All AI processing occurs in a dedicated, secure cloud environment (like Azure OpenAI Service or AWS Bedrock), with data transmitted over encrypted channels. Processed results—metadata updates, summaries, or recommendations—are written back to Core via API, with a full audit trail logged to a separate system. This architecture ensures Core remains the single source of truth, with AI acting as an intelligent, governed augmentation layer. Rollout typically begins with a single project workspace or document type, using Core's permission models to pilot the AI features with a controlled user group before enterprise-wide enablement.

IMPLEMENTATION PATTERNS

Code & Payload Examples

Automating Document Classification & Routing

Use the OpenText Core REST API to process uploaded files. A serverless function can call an LLM to analyze the document's content and purpose, then apply the correct metadata and move it to the appropriate project folder. This transforms manual filing into a zero-touch operation.

Example Python Workflow:

python
# Pseudo-code for an Azure Function triggered by Core webhook
def process_document(event):
    file_id = event['data']['id']
    # 1. Download file from Core
    file_content = core_api.download_file(file_id)
    
    # 2. Call LLM for classification
    prompt = f"Classify this document: {file_content[:5000]}"
    llm_response = openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}]
    )
    classification = parse_classification(llm_response)
    
    # 3. Update Core metadata and move file
    core_api.update_metadata(file_id, {
        "documentType": classification['type'],
        "projectId": classification['project_id'],
        "autoClassified": True
    })
    core_api.move_file(file_id, target_folder_id)

This pattern reduces manual filing effort and ensures consistent project organization.

AI-POWERED CONTENT SERVICES FOR OPENTEXT CORE

Realistic Time Savings & Operational Impact

How AI integration transforms manual content operations into intelligent, assisted workflows within OpenText Core SaaS.

Workflow	Before AI	After AI	Implementation Notes
Document Filing & Classification	Manual folder selection & tagging	AI-suggested location & auto-tagging	User confirms or overrides suggestion; learns from feedback
Project Content Discovery	Keyword search across multiple project sites	Semantic search & 'find related' suggestions	Connects to Core APIs; indexes project metadata
Collaborative Drafting	Manual compilation from source documents	AI-assisted draft assembly from referenced files	Pulls from Core document libraries; cites sources
Meeting Note Summarization	Manual transcription & highlight extraction	Auto-generated summary with action items	Processes uploaded recordings/notes; posts to Core
Content Review & Approval	Sequential manual review for compliance	AI pre-check for policy keywords & red flags	Flags potential issues for human reviewer; audit trail maintained
External Document Intake	Manual download, rename, and filing	AI-classified & filed via watched email/upload	Uses Core Capture APIs; applies project metadata
Knowledge Base Gap Identification	Periodic manual audit of documentation	AI analysis of search logs & content freshness	Suggests outdated or missing articles for update

ARCHITECTING CONTROLLED AI FOR ENTERPRISE CONTENT

Governance, Security & Phased Rollout

A practical approach to deploying AI in OpenText Core that prioritizes security, compliance, and user adoption.

A secure AI integration for OpenText Core is built on three layers: data governance, secure tool calling, and auditability. First, AI agents must operate within the platform's existing role-based access controls (RBAC), only accessing documents, projects, and workspaces the authenticated user can see. This is enforced by passing user context through the Core API and using it to filter all retrieval operations. Second, all calls to external LLMs (like Azure OpenAI or Anthropic) should be routed through a secure gateway that enforces data loss prevention policies, strips PII if required, and logs all prompts and completions. Finally, every AI-generated action—like filing a document, suggesting a tag, or drafting a summary—should create an immutable audit trail in Core, linking the AI's output to the source content, the user who triggered it, and the model version used.

We recommend a phased rollout, starting with assistive, non-destructive features to build trust and gather feedback. A typical sequence is:

Phase 1: Smart Search & Summarization. Deploy a RAG-powered Q&A agent that can answer questions about project documents without modifying any content. This validates the retrieval pipeline and security model.
Phase 2: Assisted Metadata & Filing. Introduce AI suggestions for folder placement, project association, and tag generation. Users accept or reject suggestions, keeping a human in the loop for content organization.
Phase 3: Collaborative Drafting & Workflow Triggers. Integrate AI drafting aids within Core's collaborative editing surfaces and use content analysis to automatically suggest or trigger predefined workflow routes in Core Processes.

Governance is maintained through a centralized prompt registry and regular model evaluation. Prompts for classification, summarization, and drafting are versioned and tested to ensure consistent, unbiased outputs. We implement confidence scoring and human review queues for low-confidence AI actions, especially in regulated domains. Rollout is coupled with change management: training users on the AI's capabilities and limitations, and establishing clear channels for feedback and exception reporting. This controlled approach ensures AI augments OpenText Core's content services without introducing unmanaged risk or disrupting established compliance workflows.

Enabling Efficiency, Speed & Accuracy

Intelligent Analysis, Decision & Execution

We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.

Talk to Us

Search across company data

Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.

Useful when people spend too long searching or get different answers from different systems.

Enterprise searchRAGPermissions

Automate internal workflows

Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.

Useful when repetitive work moves across multiple tools and teams.

AI agentsWorkflow automationGovernance

Add AI to products and internal tools

Build assistants, guided actions, or decision support into the software your team or customers already use.

Useful when AI needs to be part of the product, not a separate tool.

AI integrationDecision supportModel routing

IMPLEMENTATION BLUEPRINTS

Frequently Asked Questions

Practical questions for teams planning to add AI to OpenText Core for smarter content services, collaborative drafting, and project intelligence.

A production integration typically uses a middleware layer (like an Azure Function or AWS Lambda) that acts as a secure bridge.

Trigger: An event in Core (e.g., a file upload to a specific workspace, a metadata update) fires a webhook to your middleware endpoint.
Authentication: The middleware authenticates with both systems:
- OpenText Core: Uses OAuth 2.0 client credentials flow via the Core REST API.
- AI Service (e.g., Azure OpenAI): Uses API keys or managed identity stored in a secure vault like Azure Key Vault.
Data Flow: The middleware fetches the document content via the Core API, passes it to the AI model for processing, and posts the results (e.g., extracted metadata, summary) back to Core as custom properties or a linked annotation.
Security: Content is processed in-memory within the middleware; no documents are persisted in the AI service. All access is logged for audit trails. Review our guide on secure API integrations for ECM platforms for similar patterns.

About the author

Prasad Kumkar

CEO & MD, Inference Systems

Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.

His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.

Limited slotsGet a Free AI Consultation

How We Work

Custom AI workflows for your Business

One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.