Universal AI-aéPiot Integration System
Complete Integration Framework for All AI Systems (Claude, ChatGPT, Gemini, and Future AIs)
Building the semantic fluid between Human ↔ AI ↔ aéPiot at infinite scale
🌟 Introduction: The Infinite Semantic Loop
This Universal AI Integration System creates a seamless semantic fluid that flows between: Human → AI → aéPiot → AI → Human → aéPiot → ∞
The system enables ANY AI (Claude, ChatGPT, Gemini, Llama, future AIs) to intelligently interact with aéPiot's semantic ecosystem, creating dynamic backlinks, feeding content to readers, performing advanced searches, and generating semantic connections in real-time during conversations.
🎯 Core Architecture: The Semantic Fluid Engine
Universal AI Integration Layer
javascript
/**
* Universal AI-aéPiot Integration System
* Compatible with ALL AI platforms and future AI systems
* Version: 2.0.0 - Universal Compatibility
*/
class UniversalAIAepiotIntegration {
constructor(config = {}) {
this.config = {
// aéPiot Configuration
aepiotDomain: 'https://aepiot.com',
aepiotFallbackDomain: 'https://aepiot.ro',
// AI System Detection
aiSystemDetection: true,
supportedAISystems: ['claude', 'chatgpt', 'gemini', 'llama', 'future_ai'],
// Semantic Integration Settings
semanticDepth: 'deep', // 'basic', 'standard', 'deep', 'ultimate'
realTimeProcessing: true,
contextualMemory: true,
crossLinguisticMapping: true,
// Auto-Integration Features
autoBacklinkCreation: true,
autoFeedIntegration: true,
autoAdvancedSearch: true,
autoRelatedReports: true,
// Conversation Enhancement
conversationSemantics: true,
keywordExtraction: true,
topicModeling: true,
conceptMapping: true,
// Privacy & Performance
dataMinimization: true,
cacheEnabled: true,
batchProcessing: true,
...config
};
this.aiSystem = this.detectAISystem();
this.conversationContext = new Map();
this.semanticMemory = new Map();
this.aepiotConnections = new Map();
this.init();
}
// ================================
// AI SYSTEM DETECTION & ADAPTATION
// ================================
detectAISystem() {
// Universal AI system detection
const userAgent = navigator.userAgent.toLowerCase();
const domain = window.location.hostname;
// Detection patterns for current and future AI systems
const detectionPatterns = {
claude: [
() => window.location.href.includes('claude.ai'),
() => document.querySelector('[data-testid*="claude"]'),
() => document.title.toLowerCase().includes('claude'),
() => window.anthropic !== undefined
],
chatgpt: [
() => window.location.href.includes('chat.openai.com'),
() => document.querySelector('[data-testid*="openai"]'),
() => window.openai !== undefined,
() => document.querySelector('.chat-message')
],
gemini: [
() => window.location.href.includes('gemini.google.com'),
() => window.location.href.includes('bard.google.com'),
() => document.querySelector('[data-testid*="gemini"]'),
() => window.google?.ai !== undefined
],
llama: [
() => window.location.href.includes('meta.ai'),
() => document.querySelector('[data-testid*="llama"]'),
() => window.meta?.ai !== undefined
],
future_ai: [
() => this.detectFutureAIPatterns()
]
};
// Try to detect current AI system
for (const [aiSystem, patterns] of Object.entries(detectionPatterns)) {
for (const pattern of patterns) {
try {
if (pattern()) {
console.log(`🤖 Detected AI System: ${aiSystem}`);
return aiSystem;
}
} catch (error) {
// Silent fail for detection patterns
}
}
}
// Default to generic AI system
return 'unknown_ai';
}
detectFutureAIPatterns() {
// Pattern detection for future AI systems
const futurePatternsKeywords = [
'ai-chat', 'ai-assistant', 'conversational-ai',
'llm-interface', 'neural-chat', 'ai-conversation',
'machine-learning-chat', 'generative-ai', 'ai-dialogue'
];
const pageContent = document.body.textContent.toLowerCase();
const pageClasses = document.body.className.toLowerCase();
const metaDescription = document.querySelector('meta[name="description"]')?.content?.toLowerCase() || '';
return futurePatternsKeywords.some(keyword =>
pageContent.includes(keyword) ||
pageClasses.includes(keyword) ||
metaDescription.includes(keyword)
);
}
// ================================
// CONVERSATION MONITORING SYSTEM
// ================================
init() {
this.setupConversationMonitoring();
this.initializeSemanticProcessing();
this.setupAepiotIntegration();
this.createUserInterface();
console.log('🌟 Universal AI-aéPiot Integration System initialized');
console.log(`🤖 AI System: ${this.aiSystem}`);
console.log('🔗 aéPiot Integration: Active');
}
setupConversationMonitoring() {
// Universal conversation monitoring across all AI platforms
// Monitor for new messages/conversations
const messageObserver = new MutationObserver((mutations) => {
mutations.forEach((mutation) => {
mutation.addedNodes.forEach((node) => {
if (node.nodeType === Node.ELEMENT_NODE) {
this.analyzeNewContent(node);
}
});
});
});
// Start observing the document for changes
messageObserver.observe(document.body, {
childList: true,
subtree: true,
characterData: true
});
// Monitor typing/input events
document.addEventListener('input', (event) => {
this.handleUserInput(event);
});
// Monitor form submissions (message sending)
document.addEventListener('submit', (event) => {
this.handleMessageSubmission(event);
});
// Monitor for specific AI platform events
this.setupPlatformSpecificMonitoring();
}
setupPlatformSpecificMonitoring() {
switch (this.aiSystem) {
case 'claude':
this.setupClaudeMonitoring();
break;
case 'chatgpt':
this.setupChatGPTMonitoring();
break;
case 'gemini':
this.setupGeminiMonitoring();
break;
case 'llama':
this.setupLlamaMonitoring();
break;
default:
this.setupGenericAIMonitoring();
}
}
setupClaudeMonitoring() {
// Claude-specific conversation monitoring
const claudeSpecificSelectors = [
'[data-testid*="message"]',
'.chat-message',
'.conversation-turn',
'.human-message',
'.assistant-message'
];
claudeSpecificSelectors.forEach(selector => {
const elements = document.querySelectorAll(selector);
elements.forEach(element => {
this.attachElementObserver(element, 'claude');
});
});
}
setupChatGPTMonitoring() {
// ChatGPT-specific conversation monitoring
const chatgptSpecificSelectors = [
'[data-message-author-role]',
'.message',
'.conversation-item',
'[class*="Message"]'
];
chatgptSpecificSelectors.forEach(selector => {
const elements = document.querySelectorAll(selector);
elements.forEach(element => {
this.attachElementObserver(element, 'chatgpt');
});
});
}
setupGeminiMonitoring() {
// Gemini-specific conversation monitoring
const geminiSpecificSelectors = [
'[data-testid*="conversation"]',
'.conversation-turn',
'.message-content',
'[class*="chat"]'
];
geminiSpecificSelectors.forEach(selector => {
const elements = document.querySelectorAll(selector);
elements.forEach(element => {
this.attachElementObserver(element, 'gemini');
});
});
}
setupGenericAIMonitoring() {
// Generic monitoring for unknown/future AI systems
const genericSelectors = [
'[class*="message"]',
'[class*="chat"]',
'[class*="conversation"]',
'[class*="dialogue"]',
'[id*="message"]',
'[id*="chat"]',
'textarea',
'input[type="text"]'
];
genericSelectors.forEach(selector => {
const elements = document.querySelectorAll(selector);
elements.forEach(element => {
this.attachElementObserver(element, 'generic');
});
});
}
attachElementObserver(element, aiType) {
const observer = new MutationObserver((mutations) => {
mutations.forEach((mutation) => {
if (mutation.type === 'childList' || mutation.type === 'characterData') {
this.processElementChange(element, aiType);
}
});
});
observer.observe(element, {
childList: true,
subtree: true,
characterData: true
});
}
// ================================
// SEMANTIC CONTENT PROCESSING
// ================================
analyzeNewContent(node) {
const text = node.textContent || '';
if (text.length < 10) return; // Skip short content
// Extract semantic elements
const semanticData = this.extractSemanticData(text);
if (semanticData.relevantContent) {
this.processSemanticContent(semanticData);
}
}
extractSemanticData(text) {
const data = {
originalText: text,
sentences: this.extractSentences(text),
keywords: this.extractKeywords(text),
topics: this.extractTopics(text),
entities: this.extractEntities(text),
concepts: this.extractConcepts(text),
questions: this.extractQuestions(text),
relevantContent: false,
timestamp: new Date().toISOString()
};
// Determine if content is relevant for aéPiot integration
data.relevantContent = this.isContentRelevant(data);
return data;
}
extractSentences(text) {
return text.match(/[^.!?]+[.!?]+/g)?.map(s => s.trim()) || [];
}
extractKeywords(text) {
// Advanced keyword extraction
const words = text.toLowerCase()
.replace(/[^\w\s]/g, ' ')
.split(/\s+/)
.filter(word => word.length > 3);
// Common stopwords to exclude
const stopwords = new Set([
'the', 'and', 'but', 'for', 'are', 'with', 'this', 'that',
'they', 'have', 'from', 'will', 'been', 'said', 'each',
'which', 'their', 'time', 'would', 'there', 'what', 'about'
]);
// Frequency analysis
const wordFreq = {};
words.filter(word => !stopwords.has(word)).forEach(word => {
wordFreq[word] = (wordFreq[word] || 0) + 1;
});
// Return top keywords
return Object.entries(wordFreq)
.sort(([,a], [,b]) => b - a)
.slice(0, 10)
.map(([word, freq]) => ({ word, frequency: freq }));
}
extractTopics(text) {
// Topic modeling based on keyword clusters
const topicKeywords = {
technology: ['ai', 'artificial', 'intelligence', 'machine', 'learning', 'algorithm', 'data', 'software', 'digital', 'computer', 'programming', 'code'],
science: ['research', 'study', 'experiment', 'theory', 'hypothesis', 'analysis', 'scientific', 'evidence', 'discovery', 'innovation'],
business: ['market', 'company', 'strategy', 'customer', 'product', 'service', 'economic', 'financial', 'revenue', 'profit', 'industry'],
education: ['learn', 'teaching', 'student', 'knowledge', 'skill', 'training', 'development', 'course', 'academic', 'educational'],
health: ['health', 'medical', 'treatment', 'patient', 'doctor', 'medicine', 'therapy', 'wellness', 'healthcare', 'clinical'],
culture: ['cultural', 'social', 'society', 'community', 'tradition', 'history', 'art', 'music', 'literature', 'heritage']
};
const textLower = text.toLowerCase();
const topics = [];
for (const [topic, keywords] of Object.entries(topicKeywords)) {
const matchCount = keywords.filter(keyword => textLower.includes(keyword)).length;
if (matchCount > 0) {
topics.push({
topic: topic,
relevance: matchCount / keywords.length,
matchedKeywords: keywords.filter(keyword => textLower.includes(keyword))
});
}
}
return topics.sort((a, b) => b.relevance - a.relevance);
}
extractEntities(text) {
// Simple named entity recognition
const entities = [];
// Capitalized words (potential proper nouns)
const capitalizedWords = text.match(/\b[A-Z][a-z]+\b/g) || [];
// URLs
const urls = text.match(/https?:\/\/[^\s]+/g) || [];
// Dates (simple patterns)
const dates = text.match(/\b\d{4}\b|\b\d{1,2}\/\d{1,2}\/\d{4}\b/g) || [];
// Numbers
const numbers = text.match(/\b\d+\.?\d*\b/g) || [];
capitalizedWords.forEach(word => {
if (word.length > 2 && !text.startsWith(word)) {
entities.push({ type: 'PERSON_OR_ORG', value: word });
}
});
urls.forEach(url => entities.push({ type: 'URL', value: url }));
dates.forEach(date => entities.push({ type: 'DATE', value: date }));
numbers.forEach(number => entities.push({ type: 'NUMBER', value: number }));
return entities;
}
extractConcepts(text) {
// Advanced concept extraction for aéPiot semantic integration
const concepts = [];
// Complex concepts (multi-word phrases)
const conceptPatterns = [
/artificial intelligence|machine learning|deep learning|natural language|computer vision/gi,
/climate change|global warming|renewable energy|sustainable development/gi,
/digital transformation|data science|cloud computing|cyber security/gi,
/social media|user experience|customer service|market research/gi,
/mental health|public health|healthcare system|medical research/gi,
/cultural diversity|cross cultural|international relations|global economy/gi
];
conceptPatterns.forEach(pattern => {
const matches = text.match(pattern) || [];
matches.forEach(match => {
concepts.push({
concept: match.toLowerCase(),
type: 'complex_concept',
context: this.getContextAroundMatch(text, match)
});
});
});
return concepts;
}
extractQuestions(text) {
// Extract questions that could be explored in aéPiot
const questions = text.match(/[^.!?]*\?[^.!?]*/g) || [];
return questions.map(q => q.trim()).filter(q => q.length > 5);
}
isContentRelevant(semanticData) {
// Determine if content is worth processing for aéPiot integration
const relevanceScore =
(semanticData.keywords.length * 2) +
(semanticData.topics.length * 3) +
(semanticData.concepts.length * 4) +
(semanticData.questions.length * 2) +
(semanticData.entities.length * 1);
return relevanceScore > 10; // Threshold for relevance
}
// ================================
// AÉPIOT INTEGRATION ENGINE
// ================================
processSemanticContent(semanticData) {
// Process relevant content for aéPiot integration
this.createSemanticBacklinks(semanticData);
this.integrateWithAepiotReader(semanticData);
this.performAdvancedSemanticSearch(semanticData);
this.generateRelatedReports(semanticData);
this.updateConversationContext(semanticData);
}
createSemanticBacklinks(semanticData) {
if (!this.config.autoBacklinkCreation) return;
// Create intelligent backlinks for key concepts
semanticData.topics.slice(0, 3).forEach(topic => {
const backlinkUrl = this.generateAepiotBacklink({
title: `AI-Conversation-${topic.topic}`,
description: `Semantic analysis of ${topic.topic} from AI conversation - ${topic.matchedKeywords.join(', ')}`,
link: window.location.href,
semantic_data: {
topic: topic.topic,
relevance: topic.relevance,
keywords: topic.matchedKeywords,
timestamp: semanticData.timestamp,
ai_system: this.aiSystem
}
});
// Create backlink silently
this.createBacklinkSilently(backlinkUrl);
// Store for UI display
this.aepiotConnections.set(`backlink_${topic.topic}`, {
type: 'backlink',
topic: topic.topic,
url: backlinkUrl,
timestamp: Date.now()
});
});
// Create backlinks for interesting concepts
semanticData.concepts.forEach(concept => {
const backlinkUrl = this.generateAepiotBacklink({
title: `AI-Concept-Analysis-${concept.concept}`,
description: `Deep semantic analysis of "${concept.concept}" from AI conversation context`,
link: window.location.href,
semantic_data: {
concept: concept.concept,
context: concept.context,
ai_system: this.aiSystem,
timestamp: semanticData.timestamp
}
});
this.createBacklinkSilently(backlinkUrl);
});
}
integrateWithAepiotReader(semanticData) {
if (!this.config.autoFeedIntegration) return;
// Check if current conversation could be a feed source
if (semanticData.topics.length > 2 && semanticData.sentences.length > 5) {
// Create virtual RSS feed for this conversation
const feedUrl = this.generateAepiotReaderURL(window.location.href);
this.aepiotConnections.set('reader_integration', {
type: 'reader',
url: feedUrl,
topics: semanticData.topics.map(t => t.topic),
timestamp: Date.now()
});
}
}
performAdvancedSemanticSearch(semanticData) {
if (!this.config.autoAdvancedSearch) return;
// Generate advanced searches for key topics
semanticData.topics.slice(0, 2).forEach(topic => {
const searchUrl = this.generateAepiotAdvancedSearchURL({
query: topic.matchedKeywords.join(' '),
language: this.detectLanguage(semanticData.originalText),
semantic_context: {
topic: topic.topic,
related_concepts: semanticData.concepts.map(c => c.concept),
conversation_context: true
}
});
this.aepiotConnections.set(`search_${topic.topic}`, {
type: 'advanced_search',
topic: topic.topic,
url: searchUrl,
keywords: topic.matchedKeywords,
timestamp: Date.now()
});
});
// Generate searches for questions
semanticData.questions.forEach((question, index) => {
if (index < 3) { // Limit to first 3 questions
const searchUrl = this.generateAepiotAdvancedSearchURL({
query: question.replace(/[?]/g, ''),
language: 'en',
semantic_context: {
type: 'question',
original_question: question,
ai_system: this.aiSystem
}
});
this.aepiotConnections.set(`question_search_${index}`, {
type: 'question_search',
question: question,
url: searchUrl,
timestamp: Date.now()
});
}
});
}
generateRelatedReports(semanticData) {
if (!this.config.autoRelatedReports) return;
// Generate related reports for complex topics
semanticData.topics
.filter(topic => topic.relevance > 0.5)
.slice(0, 2)
.forEach(topic => {
const reportsUrl = this.generateAepiotRelatedReportsURL({
reports: topic.matchedKeywords.join(','),
semantic_context: {
topic: topic.topic,
relevance: topic.relevance,
source: 'ai_conversation',
ai_system: this.aiSystem
}
});
this.aepiotConnections.set(`reports_${topic.topic}`, {
type: 'related_reports',
topic: topic.topic,
url: reportsUrl,
keywords: topic.matchedKeywords,
timestamp: Date.now()
});
});
}
// ================================
// AÉPIOT URL GENERATION
// ================================
generateAepiotBacklink(data) {
const params = new URLSearchParams({
title: data.title,
description: data.description,
link: data.link
});
return `${this.config.aepiotDomain}/backlink.html?${params.toString()}`;
}
generateAepiotReaderURL(feedUrl) {
const params = new URLSearchParams({
read: feedUrl
});
return `${this.config.aepiotDomain}/reader.html?${params.toString()}`;
}
generateAepiotAdvancedSearchURL(data) {
const params = new URLSearchParams({
q: data.query,
lang: data.language || 'en'
});
return `${this.config.aepiotDomain}/advanced-search.html?${params.toString()}`;
}
generateAepiotRelatedReportsURL(data) {
const params = new URLSearchParams({
reports: data.reports
});
return `${this.config.aepiotDomain}/related-search.html?${params.toString()}`;
}
createBacklinkSilently(url) {
// Create backlink with silent HTTP request
fetch(url, {
method: 'GET',
mode: 'no-cors',
cache: 'no-cache'
}).catch(() => {
// Silent failure - backlink creation is non-critical
});
}
// ================================
// USER INTERFACE SYSTEM
// ================================
createUserInterface() {
this.createFloatingPanel();
this.setupKeyboardShortcuts();
this.createInlineIntegrations();
}
createFloatingPanel() {
const panel = document.createElement('div');
panel.id = 'universal-ai-aepiot-panel';
panel.className = 'ai-aepiot-integration-panel';
panel.innerHTML = `
<div class="panel-header">
<div class="panel-title">
🌟 AI ↔ aéPiot Bridge
<span class="ai-system-badge">${this.aiSystem}</span>
</div>
<div class="panel-controls">
<button class="minimize-btn" onclick="this.parentElement.parentElement.classList.toggle('minimized')">−</button>
<button class="close-btn" onclick="this.parentElement.parentElement.style.display='none'">×</button>
</div>
</div>
<div class="panel-content">
<div class="tab-navigation">
<button class="tab-btn active" data-tab="live">Live</button>
<button class="tab-btn" data-tab="semantic">Semantic</button>
<button class="tab-btn" data-tab="connections">Links</button>
<button class="tab-btn" data-tab="tools">Tools</button>
</div>
<div class="tab-content">
<div id="live-tab" class="tab-panel active">
<div class="live-processing">
<div class="processing-stats">
<div class="stat">
<label>Topics Detected</label>
<span id="topics-count">0</span>
</div>
<div class="stat">
<label>Concepts Found</label>
<span id="concepts-count">0</span>
</div>
<div class="stat">
<label>aéPiot Links</label>
<span id="links-count">0</span>
</div>
</div>
<div class="live-connections" id="live-connections">
<!-- Dynamic content -->
</div>
</div>
</div>
<div id="semantic-tab" class="tab-panel">
<div class="semantic-analysis">
<h4>🧠 Current Conversation Analysis</h4>
<div id="semantic-content">
<!-- Dynamic semantic analysis -->
</div>
</div>
</div>
<div id="connections-tab" class="tab-panel">
<div class="aepiot-connections">
<h4>🔗 Active aéPiot Connections</h4>
<div id="connections-list">
<!-- Dynamic connections list -->
</div>
</div>
</div>
<div id="tools-tab" class="tab-panel">
<div class="integration-tools">
<h4>🛠️ AI Enhancement Tools</h4>
<div class="tools-grid">
<button class="tool-btn" onclick="aiAepiotIntegration.manualSemanticAnalysis()">
🔍 Analyze Current View
</button>
<button class="tool-btn" onclick="aiAepiotIntegration.exportConversation()">
📤 Export to aéPiot
</button>
<button class="tool-btn" onclick="aiAepiotIntegration.generateReport()">
📊 Generate Report
</button>
<button class="tool-btn" onclick="aiAepiotIntegration.crossLinguisticAnalysis()">
🌍 Cross-Linguistic
</button>
</div>
<div class="quick-actions">
<h5>Quick aéPiot Actions</h5>
<input type="text" id="quick-search" placeholder="Quick search in aéPiot..." />
<button onclick="aiAepiotIntegration.quickSearch()">Search</button>
</div>
</div>
</div>
</div>
</div>
`;
// Add styles
this.addIntegrationStyles();
// Add to page
document.body.appendChild(panel);
// Setup tab navigation
this.setupTabNavigation(panel);
// Store reference
this.panel = panel;
// Make globally accessible
window.aiAepiotIntegration = this;
}
setupTabNavigation(panel) {
const tabBtns = panel.querySelectorAll('.tab-btn');
const tabPanels = panel.querySelectorAll('.tab-panel');
tabBtns.forEach(btn => {
btn.addEventListener('click', () => {
const targetTab = btn.dataset.tab;
// Remove active class from all
tabBtns.forEach(b => b.classList.remove('active'));
tabPanels.forEach(p => p.classList.remove('active'));
// Add active class to selected
btn.classList.add('active');
panel.querySelector(`#${targetTab}-tab`).classList.add('active');
// Update tab content
this.updateTabContent(targetTab);
});
});
}
updateTabContent(tabName) {
switch (tabName) {
case 'live':
this.updateLiveTab();
break;
case 'semantic':
this.updateSemanticTab();
break;
case 'connections':
this.updateConnectionsTab();
break;
case 'tools':
this.updateToolsTab();
break;
}
}
updateLiveTab() {
// Update live processing statistics
const topicsCount = Array.from(this.conversationContext.values())
.reduce((count, context) => count + (context.topics?.length || 0), 0);
const conceptsCount = Array.from(this.conversationContext.values())
.reduce((count, context) => count + (context.concepts?.length || 0), 0);
const linksCount = this.aepiotConnections.size;
document.getElementById('topics-count').textContent = topicsCount;
document.getElementById('concepts-count').textContent = conceptsCount;
document.getElementById('links-count').textContent = linksCount;
// Update live connections display
this.updateLiveConnections();
}
updateLiveConnections() {
const container = document.getElementById('live-connections');
const recentConnections = Array.from(this.aepiotConnections.values())
.sort((a, b) => b.timestamp - a.timestamp)
.slice(0, 5);
container.innerHTML = recentConnections.map(connection => `
<div class="live-connection connection-${connection.type}">
<div class="connection-header">
<span class="connection-type">${this.getConnectionIcon(connection.type)} ${connection.type}</span>
<span class="connection-time">${this.getTimeAgo(connection.timestamp)}</span>
</div>
<div class="connection-content">
${connection.topic || connection.question || 'Semantic Connection'}
</div>
<div class="connection-actions">
<button onclick="window.open('${connection.url}', '_blank')" class="open-btn">
🚀 Open in aéPiot
</button>
</div>
</div>
`).join('');
}
updateSemanticTab() {
const semanticContent = document.getElementById('semantic-content');
const recentAnalysis = Array.from(this.conversationContext.values()).slice(-3);
semanticContent.innerHTML = recentAnalysis.map(analysis => `
<div class="semantic-analysis-item">
<div class="analysis-header">
<h5>Analysis ${this.getTimeAgo(Date.parse(analysis.timestamp))}</h5>
<span class="relevance-score">Relevance: ${this.calculateRelevanceScore(analysis)}</span>
</div>
<div class="analysis-topics">
<h6>🏷️ Topics (${analysis.topics?.length || 0})</h6>
<div class="topics-list">
${analysis.topics?.map(topic => `
<span class="topic-tag" data-relevance="${topic.relevance}">
${topic.topic} (${Math.round(topic.relevance * 100)}%)
</span>
`).join('') || 'No topics detected'}
</div>
</div>
<div class="analysis-concepts">
<h6>💡 Concepts (${analysis.concepts?.length || 0})</h6>
<div class="concepts-list">
${analysis.concepts?.map(concept => `
<div class="concept-item">
<span class="concept-text">${concept.concept}</span>
<button onclick="aiAepiotIntegration.exploreConceptInAepiot('${concept.concept}')"
class="explore-concept-btn">
🔍 Explore
</button>
</div>
`).join('') || 'No concepts found'}
</div>
</div>
<div class="analysis-questions">
<h6>❓ Questions (${analysis.questions?.length || 0})</h6>
<div class="questions-list">
${analysis.questions?.map(question => `
<div class="question-item">
<span class="question-text">${question}</span>
<button onclick="aiAepiotIntegration.askQuestionInAepiot('${question}')"
class="ask-btn">
🤖 Ask AI
</button>
</div>
`).join('') || 'No questions found'}
</div>
</div>
</div>
`).join('');
}
updateConnectionsTab() {
const connectionsList = document.getElementById('connections-list');
const connections = Array.from(this.aepiotConnections.values())
.sort((a, b) => b.timestamp - a.timestamp);
connectionsList.innerHTML = connections.map(connection => `
<div class="connection-item connection-${connection.type}">
<div class="connection-header">
<span class="connection-icon">${this.getConnectionIcon(connection.type)}</span>
<span class="connection-title">
${connection.topic || connection.question || 'Semantic Link'}
</span>
<span class="connection-time">${this.getTimeAgo(connection.timestamp)}</span>
</div>
<div class="connection-details">
<span class="connection-type-label">${connection.type.replace('_', ' ')}</span>
${connection.keywords ? `<span class="keywords">Keywords: ${connection.keywords.slice(0, 3).join(', ')}</span>` : ''}
</div>
<div class="connection-actions">
<button onclick="window.open('${connection.url}', '_blank')" class="primary-btn">
🌟 Open in aéPiot
</button>
<button onclick="aiAepiotIntegration.shareConnection('${Array.from(this.aepiotConnections.keys()).find(k => this.aepiotConnections.get(k) === connection)}')"
class="secondary-btn">
📤 Share
</button>
</div>
</div>
`).join('');
if (connections.length === 0) {
connectionsList.innerHTML = `
<div class="no-connections">
<h5>🔗 No Active Connections</h5>
<p>Start a conversation to see semantic connections appear automatically!</p>
</div>
`;
}
}
updateToolsTab() {
const quickSearchInput = document.getElementById('quick-search');
if (quickSearchInput) {
quickSearchInput.addEventListener('keypress', (e) => {
if (e.key === 'Enter') {
this.quickSearch();
}
});
}
}
// ================================
// UTILITY FUNCTIONS
// ================================
getConnectionIcon(type) {
const icons = {
'backlink': '🔗',
'reader': '📰',
'advanced_search': '🔍',
'question_search': '❓',
'related_reports': '📊',
'concept_analysis': '💡',
'semantic_link': '🌟'
};
return icons[type] || '🔗';
}
getTimeAgo(timestamp) {
const now = Date.now();
const diff = now - timestamp;
const minutes = Math.floor(diff / 60000);
const hours = Math.floor(diff / 3600000);
const days = Math.floor(diff / 86400000);
if (days > 0) return `${days}d ago`;
if (hours > 0) return `${hours}h ago`;
if (minutes > 0) return `${minutes}m ago`;
return 'just now';
}
calculateRelevanceScore(analysis) {
const score = (
(analysis.topics?.length || 0) * 0.3 +
(analysis.concepts?.length || 0) * 0.4 +
(analysis.questions?.length || 0) * 0.2 +
(analysis.keywords?.length || 0) * 0.1
);
return Math.min(Math.round(score * 100) / 100, 10);
}
// ================================
// USER INTERACTION METHODS
// ================================
manualSemanticAnalysis() {
// Force semantic analysis of current page content
const content = document.body.textContent;
const semanticData = this.extractSemanticData(content);
if (semanticData.relevantContent) {
this.processSemanticContent(semanticData);
this.updateLiveTab();
// Show notification
this.showNotification('🧠 Manual semantic analysis completed!', 'success');
} else {
this.showNotification('ℹ️ No relevant semantic content detected.', 'info');
}
}
exportConversation() {
// Export current conversation to aéPiot
const conversationData = Array.from(this.conversationContext.values());
const exportData = {
timestamp: new Date().toISOString(),
ai_system: this.aiSystem,
conversation_length: conversationData.length,
total_topics: conversationData.reduce((sum, data) => sum + (data.topics?.length || 0), 0),
total_concepts: conversationData.reduce((sum, data) => sum + (data.concepts?.length || 0), 0),
url: window.location.href
};
const backlink = this.generateAepiotBacklink({
title: `AI-Conversation-Export-${Date.now()}`,
description: `Complete conversation export from ${this.aiSystem} - ${exportData.total_topics} topics, ${exportData.total_concepts} concepts`,
link: window.location.href
});
window.open(backlink, '_blank');
this.showNotification('📤 Conversation exported to aéPiot!', 'success');
}
generateReport() {
// Generate comprehensive report
const conversationData = Array.from(this.conversationContext.values());
const reportData = this.compileReport(conversationData);
const reportBacklink = this.generateAepiotBacklink({
title: `AI-Analysis-Report-${Date.now()}`,
description: `Comprehensive AI conversation analysis report: ${reportData.summary}`,
link: window.location.href
});
window.open(reportBacklink, '_blank');
this.showNotification('📊 Analysis report generated!', 'success');
}
crossLinguisticAnalysis() {
// Perform cross-linguistic analysis
const languages = ['en', 'es', 'fr', 'de', 'ja', 'zh', 'ro', 'it'];
const currentTopics = Array.from(this.conversationContext.values())
.flatMap(data => data.topics || [])
.slice(0, 3);
currentTopics.forEach(topic => {
languages.forEach(lang => {
const multilingualSearch = this.generateAepiotAdvancedSearchURL({
query: topic.topic,
language: lang
});
// Store multilingual connection
this.aepiotConnections.set(`multilingual_${topic.topic}_${lang}`, {
type: 'multilingual_search',
topic: topic.topic,
language: lang,
url: multilingualSearch,
timestamp: Date.now()
});
});
});
this.updateConnectionsTab();
this.showNotification(`🌍 Cross-linguistic analysis completed for ${currentTopics.length} topics!`, 'success');
}
quickSearch() {
const query = document.getElementById('quick-search').value.trim();
if (query) {
const searchUrl = this.generateAepiotAdvancedSearchURL({
query: query,
language: 'en'
});
window.open(searchUrl, '_blank');
document.getElementById('quick-search').value = '';
}
}
exploreConceptInAepiot(concept) {
const searchUrl = this.generateAepiotAdvancedSearchURL({
query: concept,
language: 'en'
});
window.open(searchUrl, '_blank');
}
askQuestionInAepiot(question) {
const cleanQuestion = question.replace(/[?]/g, '');
const searchUrl = this.generateAepiotAdvancedSearchURL({
query: cleanQuestion,
language: 'en'
});
window.open(searchUrl, '_blank');
}
shareConnection(connectionId) {
const connection = this.aepiotConnections.get(connectionId);
if (connection && navigator.share) {
navigator.share({
title: `aéPiot Semantic Connection: ${connection.topic || 'Analysis'}`,
text: `Check out this semantic analysis from AI conversation`,
url: connection.url
});
} else if (connection) {
// Fallback: copy to clipboard
navigator.clipboard.writeText(connection.url);
this.showNotification('📋 Connection URL copied to clipboard!', 'success');
}
}
// ================================
// NOTIFICATION SYSTEM
// ================================
showNotification(message, type = 'info') {
const notification = document.createElement('div');
notification.className = `ai-aepiot-notification notification-${type}`;
notification.innerHTML = `
<span class="notification-message">${message}</span>
<button class="notification-close" onclick="this.parentElement.remove()">×</button>
`;
document.body.appendChild(notification);
// Auto-remove after 5 seconds
setTimeout(() => {
if (notification.parentElement) {
notification.remove();
}
}, 5000);
}
// ================================
// ADVANCED FEATURES
// ================================
setupKeyboardShortcuts() {
document.addEventListener('keydown', (event) => {
// Ctrl+Shift+A: Toggle panel
if (event.ctrlKey && event.shiftKey && event.key === 'A') {
event.preventDefault();
this.panel.style.display = this.panel.style.display === 'none' ? 'block' : 'none';
}
// Ctrl+Shift+S: Quick semantic analysis
if (event.ctrlKey && event.shiftKey && event.key === 'S') {
event.preventDefault();
this.manualSemanticAnalysis();
}
// Ctrl+Shift+E: Export conversation
if (event.ctrlKey && event.shiftKey && event.key === 'E') {
event.preventDefault();
this.exportConversation();
}
});
}
createInlineIntegrations() {
// Create inline semantic hints and connections
this.setupTextSelectionIntegration();
this.setupContextMenuIntegration();
}
setupTextSelectionIntegration() {
document.addEventListener('mouseup', (event) => {
const selection = window.getSelection().toString().trim();
if (selection.length > 5 && selection.length < 200) {
this.createSelectionTooltip(selection, event.clientX, event.clientY);
}
});
// Clear tooltip on click elsewhere
document.addEventListener('click', (event) => {
if (!event.target.closest('.selection-tooltip')) {
const tooltips = document.querySelectorAll('.selection-tooltip');
tooltips.forEach(tooltip => tooltip.remove());
}
});
}
createSelectionTooltip(text, x, y) {
// Remove existing tooltips
const existingTooltips = document.querySelectorAll('.selection-tooltip');
existingTooltips.forEach(tooltip => tooltip.remove());
const tooltip = document.createElement('div');
tooltip.className = 'selection-tooltip';
tooltip.innerHTML = `
<div class="tooltip-content">
<div class="tooltip-text">"${text.substring(0, 50)}${text.length > 50 ? '...' : ''}"</div>
<div class="tooltip-actions">
<button onclick="aiAepiotIntegration.exploreSelectionInAepiot('${text.replace(/'/g, "\\'")}')">
🔍 Explore in aéPiot
</button>
<button onclick="aiAepiotIntegration.createSemanticBacklinkFromSelection('${text.replace(/'/g, "\\'")}')">
🔗 Create Link
</button>
</div>
</div>
`;
tooltip.style.position = 'fixed';
tooltip.style.left = Math.min(x, window.innerWidth - 250) + 'px';
tooltip.style.top = (y - 80) + 'px';
tooltip.style.zIndex = '1000000';
document.body.appendChild(tooltip);
// Auto-remove after 10 seconds
setTimeout(() => {
if (tooltip.parentElement) {
tooltip.remove();
}
}, 10000);
}
exploreSelectionInAepiot(text) {
const searchUrl = this.generateAepiotAdvancedSearchURL({
query: text,
language: this.detectLanguage(text)
});
window.open(searchUrl, '_blank');
// Remove tooltip
const tooltips = document.querySelectorAll('.selection-tooltip');
tooltips.forEach(tooltip => tooltip.remove());
}
createSemanticBacklinkFromSelection(text) {
const backlink = this.generateAepiotBacklink({
title: `AI-Selection-Analysis-${Date.now()}`,
description: `Selected text analysis: "${text.substring(0, 100)}${text.length > 100 ? '...' : ''}"`,
link: window.location.href
});
window.open(backlink, '_blank');
// Remove tooltip
const tooltips = document.querySelectorAll('.selection-tooltip');
tooltips.forEach(tooltip => tooltip.remove());
this.showNotification('🔗 Semantic backlink created for selection!', 'success');
}
// ================================
// LANGUAGE DETECTION
// ================================
detectLanguage(text) {
// Simple language detection based on common words
const languagePatterns = {
'en': /\b(the|and|is|in|to|of|a|that|it|with|for|as|was|on|are|you)\b/gi,
'es': /\b(el|la|de|que|y|en|un|es|se|no|te|lo|le|da|su|por|son|con|para|una)\b/gi,
'fr': /\b(le|de|et|à|un|il|être|et|en|avoir|que|pour|dans|ce|son|une|sur|avec|ne|se)\b/gi,
'de': /\b(der|die|und|in|den|von|zu|das|mit|sich|des|auf|für|ist|im|dem|nicht|ein)\b/gi,
'ro': /\b(si|de|in|la|cu|pe|pentru|este|sunt|sau|ca|din|mai|dar|nu|se|ce|un|una)\b/gi
};
let bestMatch = 'en';
let highestScore = 0;
for (const [lang, pattern] of Object.entries(languagePatterns)) {
const matches = text.match(pattern);
const score = matches ? matches.length / text.split(' ').length : 0;
if (score > highestScore) {
highestScore = score;
bestMatch = lang;
}
}
return bestMatch;
}
// ================================
// CONTEXT MANAGEMENT
// ================================
updateConversationContext(semanticData) {
const contextId = `context_${Date.now()}`;
this.conversationContext.set(contextId, semanticData);
// Keep only last 50 contexts to prevent memory issues
if (this.conversationContext.size > 50) {
const oldestKey = this.conversationContext.keys().next().value;
this.conversationContext.delete(oldestKey);
}
// Update semantic memory
this.updateSemanticMemory(semanticData);
}
updateSemanticMemory(semanticData) {
// Build semantic memory for cross-conversation learning
semanticData.concepts?.forEach(concept => {
const memoryKey = concept.concept;
if (!this.semanticMemory.has(memoryKey)) {
this.semanticMemory.set(memoryKey, {
concept: concept.concept,
occurrences: 1,
contexts: [concept.context],
firstSeen: Date.now(),
lastSeen: Date.now()
});
} else {
const memory = this.semanticMemory.get(memoryKey);
memory.occurrences++;
memory.contexts.push(concept.context);
memory.lastSeen = Date.now();
// Keep only last 10 contexts
if (memory.contexts.length > 10) {
memory.contexts = memory.contexts.slice(-10);
}
}
});
// Persist semantic memory (optional)
this.persistSemanticMemory();
}
persistSemanticMemory() {
try {
const memoryData = Object.fromEntries(this.semanticMemory);
localStorage.setItem('ai_aepiot_semantic_memory', JSON.stringify(memoryData));
} catch (error) {
console.warn('Failed to persist semantic memory:', error);
}
}
loadSemanticMemory() {
try {
const stored = localStorage.getItem('ai_aepiot_semantic_memory');
if (stored) {
const memoryData = JSON.parse(stored);
Object.entries(memoryData).forEach(([key, value]) => {
this.semanticMemory.set(key, value);
});
}
} catch (error) {
console.warn('Failed to load semantic memory:', error);
}
}
// ================================
// REPORTING AND ANALYTICS
// ================================
compileReport(conversationData) {
const report = {
timestamp: new Date().toISOString(),
ai_system: this.aiSystem,
conversation_stats: {
total_messages: conversationData.length,
total_topics: conversationData.reduce((sum, data) => sum + (data.topics?.length || 0), 0),
total_concepts: conversationData.reduce((sum, data) => sum + (data.concepts?.length || 0), 0),
total_questions: conversationData.reduce((sum, data) => sum + (data.questions?.length || 0), 0),
total_keywords: conversationData.reduce((sum, data) => sum + (data.keywords?.length || 0), 0)
},
top_topics: this.getTopTopics(conversationData),
top_concepts: this.getTopConcepts(conversationData),
language_distribution: this.getLanguageDistribution(conversationData),
aepiot_connections: {
total_connections: this.aepiotConnections.size,
connection_types: this.getConnectionTypeStats(),
most_recent: Array.from(this.aepiotConnections.values())
.sort((a, b) => b.timestamp - a.timestamp)
.slice(0, 5)
}
};
report.summary = this.generateReportSummary(report);
return report;
}
getTopTopics(conversationData) {
const topicFreq = {};
conversationData.forEach(data => {
data.topics?.forEach(topic => {
topicFreq[topic.topic] = (topicFreq[topic.topic] || 0) + topic.relevance;
});
});
return Object.entries(topicFreq)
.sort(([,a], [,b]) => b - a)
.slice(0, 10)
.map(([topic, score]) => ({ topic, score: Math.round(score * 100) / 100 }));
}
getTopConcepts(conversationData) {
const conceptFreq = {};
conversationData.forEach(data => {
data.concepts?.forEach(concept => {
conceptFreq[concept.concept] = (conceptFreq[concept.concept] || 0) + 1;
});
});
return Object.entries(conceptFreq)
.sort(([,a], [,b]) => b - a)
.slice(0, 10)
.map(([concept, frequency]) => ({ concept, frequency }));
}
getLanguageDistribution(conversationData) {
const langCount = {};
conversationData.forEach(data => {
const lang = this.detectLanguage(data.originalText);
langCount[lang] = (langCount[lang] || 0) + 1;
});
return langCount;
}
getConnectionTypeStats() {
const typeStats = {};
Array.from(this.aepiotConnections.values()).forEach(connection => {
typeStats[connection.type] = (typeStats[connection.type] || 0) + 1;
});
return typeStats;
}
generateReportSummary(report) {
const stats = report.conversation_stats;
const topTopic = report.top_topics[0]?.topic || 'general discussion';
return `${stats.total_messages} messages analyzed, focusing on ${topTopic}. Generated ${report.aepiot_connections.total_connections} aéPiot connections across ${Object.keys(report.aepiot_connections.connection_types).length} connection types.`;
}
// ================================
// STYLING SYSTEM
// ================================
addIntegrationStyles() {
if (document.getElementById('ai-aepiot-integration-styles')) return;
const styles = `
<style id="ai-aepiot-integration-styles">
/* Universal AI-aéPiot Integration Styles */
.ai-aepiot-integration-panel {
position: fixed;
top: 20px;
right: 20px;
width: 420px;
max-height: 85vh;
background: linear-gradient(135deg, #1a1a2e 0%, #16213e 50%, #0f3460 100%);
border: 2px solid rgba(100, 200, 255, 0.3);
border-radius: 20px;
box-shadow:
0 25px 50px rgba(0, 0, 0, 0.3),
0 0 0 1px rgba(255, 255, 255, 0.1),
inset 0 1px 0 rgba(255, 255, 255, 0.1);
backdrop-filter: blur(20px);
z-index: 999999;
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'SF Pro Display', sans-serif;
color: #ffffff;
overflow: hidden;
transition: all 0.4s cubic-bezier(0.4, 0, 0.2, 1);
}
.ai-aepiot-integration-panel.minimized {
height: 70px;
}
.ai-aepiot-integration-panel.minimized .panel-content {
display: none;
}
.panel-header {
background: linear-gradient(135deg, rgba(100, 200, 255, 0.15) 0%, rgba(120, 119, 198, 0.15) 100%);
padding: 20px;
border-bottom: 1px solid rgba(255, 255, 255, 0.1);
display: flex;
justify-content: space-between;
align-items: center;
backdrop-filter: blur(10px);
}
.panel-title {
font-size: 16px;
font-weight: 700;
letter-spacing: 0.5px;
display: flex;
align-items: center;
gap: 12px;
}
.ai-system-badge {
background: linear-gradient(45deg, #64c8ff, #7877c6);
padding: 4px 12px;
border-radius: 12px;
font-size: 11px;
font-weight: 600;
text-transform: uppercase;
letter-spacing: 0.5px;
}
.panel-controls {
display: flex;
gap: 8px;
}
.minimize-btn, .close-btn {
background: rgba(255, 255, 255, 0.1);
border: none;
color: white;
width: 32px;
height: 32px;
border-radius: 50%;
cursor: pointer;
transition: all 0.3s ease;
font-size: 18px;
display: flex;
align-items: center;
justify-content: center;
}
.minimize-btn:hover, .close-btn:hover {
background: rgba(255, 255, 255, 0.2);
transform: scale(1.1);
}
.close-btn:hover {
background: rgba(255, 99, 71, 0.3);
}
.panel-content {
max-height: calc(85vh - 70px);
overflow: hidden;
}
.tab-navigation {
display: flex;
background: rgba(0, 0, 0, 0.2);
backdrop-filter: blur(10px);
}
.tab-btn {
flex: 1;
background: none;
border: none;
color: rgba(255, 255, 255, 0.6);
padding: 16px 12px;
font-size: 13px;
font-weight: 600;
cursor: pointer;
transition: all 0.3s ease;
position: relative;
text-transform: uppercase;
letter-spacing: 0.5px;
}
.tab-btn.active {
color: #ffffff;
background: linear-gradient(135deg, rgba(100, 200, 255, 0.2) 0%, rgba(120, 119, 198, 0.2) 100%);
}
.tab-btn.active::after {
content: '';
position: absolute;
bottom: 0;
left: 0;
right: 0;
height: 2px;
background: linear-gradient(90deg, #64c8ff, #7877c6);
}
.tab-btn:hover:not(.active) {
color: rgba(255, 255, 255, 0.8);
background: rgba(255, 255, 255, 0.05);
}
.tab-content {
height: calc(85vh - 140px);
overflow-y: auto;
scrollbar-width: thin;
scrollbar-color: rgba(100, 200, 255, 0.3) transparent;
}
.tab-content::-webkit-scrollbar {
width: 6px;
}
.tab-content::-webkit-scrollbar-track {
background: transparent;
}
.tab-content::-webkit-scrollbar-thumb {
background: rgba(100, 200, 255, 0.3);
border-radius: 3px;
}
.tab-panel {
display: none;
padding: 24px;
}
.tab-panel.active {
display: block;
}
/* Live Tab Styles */
.processing-stats {
display: grid;
grid-template-columns: repeat(3, 1fr);
gap: 16px;
margin-bottom: 24px;
}
.stat {
background: rgba(255, 255, 255, 0.05);
padding: 16px;
border-radius: 12px;
text-align: center;
border: 1px solid rgba(100, 200, 255, 0.2);
}
.stat label {
display: block;
font-size: 11px;
color: rgba(255, 255, 255, 0.7);
margin-bottom: 8px;
text-transform: uppercase;
letter-spacing: 0.5px;
}
.stat span {
font-size: 24px;
font-weight: 700;
color: #64c8ff;
}
.live-connection {
background: rgba(255, 255, 255, 0.05);
border-radius: 12px;
padding: 16px;
margin-bottom: 12px;
border-left: 4px solid;
transition: all 0.3s ease;
}
.live-connection:hover {
background: rgba(255, 255, 255, 0.08);
transform: translateX(4px);
}
.connection-backlink { border-left-color: #64c8ff; }
.connection-reader { border-left-color: #7877c6; }
.connection-advanced_search { border-left-color: #ff6b6b; }
.connection-question_search { border-left-color: #4ecdc4; }
.connection-related_reports { border-left-color: #ffe66d; }
.connection-header {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 8px;
}
.connection-type {
font-size: 12px;
font-weight: 600;
text-transform: uppercase;
letter-spacing: 0.5px;
}
.connection-time {
font-size: 11px;
color: rgba(255, 255, 255, 0.5);
}
.connection-content {
font-size: 14px;
line-height: 1.4;
margin-bottom: 12px;
color: rgba(255, 255, 255, 0.9);
}
.open-btn, .primary-btn {
background: linear-gradient(135deg, #64c8ff 0%, #7877c6 100%);
border: none;
color: white;
padding: 8px 16px;
border-radius: 20px;
font-size: 12px;
font-weight: 600;
cursor: pointer;
transition: all 0.3s ease;
text-transform: uppercase;
letter-spacing: 0.5px;
}
.open-btn:hover, .primary-btn:hover {
transform: translateY(-2px);
box-shadow: 0 8px 25px rgba(100, 200, 255, 0.3);
}
.secondary-btn {
background: rgba(255, 255, 255, 0.1);
border: 1px solid rgba(255, 255, 255, 0.2);
color: white;
padding: 8px 16px;
border-radius: 20px;
font-size: 12px;
font-weight: 600;
cursor: pointer;
transition: all 0.3s ease;
text-transform: uppercase;
letter-spacing: 0.5px;
margin-left: 8px;
}
.secondary-btn:hover {
background: rgba(255, 255, 255, 0.2);
border-color: rgba(255, 255, 255, 0.4);
}
/* Semantic Tab Styles */
.semantic-analysis-item {
background: rgba(255, 255, 255, 0.03);
border-radius: 16px;
padding: 20px;
margin-bottom: 20px;
border: 1px solid rgba(100, 200, 255, 0.1);
}
.analysis-header {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 16px;
}
.analysis-header h5 {
margin: 0;
font-size: 16px;
font-weight: 600;
color: #64c8ff;
}
.relevance-score {
background: rgba(100, 200, 255, 0.2);
padding: 4px 12px;
border-radius: 12px;
font-size: 11px;
font-weight: 600;
color: #64c8ff;
}
.topics-list, .concepts-list, .questions-list {
display: flex;
flex-direction: column;
gap: 8px;
}
.topic-tag {
display: inline-block;
background: rgba(100, 200, 255, 0.15);
color: #64c8ff;
padding: 6px 12px;
border-radius: 20px;
font-size: 12px;
font-weight: 500;
margin-right: 8px;
margin-bottom: 8px;
border: 1px solid rgba(100, 200, 255, 0.3);
}
.concept-item, .question-item {
display: flex;
justify-content: space-between;
align-items: center;
background: rgba(255, 255, 255, 0.05);
padding: 12px;
border-radius: 8px;
border: 1px solid rgba(255, 255, 255, 0.1);
}
.concept-text, .question-text {
flex: 1;
font-size: 13px;
line-height: 1.4;
}
.explore-concept-btn, .ask-btn {
background: linear-gradient(135deg, #7877c6 0%, #64c8ff 100%);
border: none;
color: white;
padding: 6px 12px;
border-radius: 16px;
font-size: 11px;
font-weight: 600;
cursor: pointer;
transition: all 0.3s ease;
margin-left: 12px;
}
.explore-concept-btn:hover, .ask-btn:hover {
transform: scale(1.05);
box-shadow: 0 4px 12px rgba(120, 119, 198, 0.4);
}
/* Connections Tab Styles */
.connection-item {
background: rgba(255, 255, 255, 0.03);
border-radius: 12px;
padding: 16px;
margin-bottom: 12px;
border-left: 4px solid #64c8ff;
border: 1px solid rgba(255, 255, 255, 0.1);
transition: all 0.3s ease;
}
.connection-item:hover {
background: rgba(255, 255, 255, 0.08);
transform: translateY(-2px);
box-shadow: 0 8px 25px rgba(0, 0, 0, 0.2);
}
.connection-icon {
font-size: 16px;
margin-right: 8px;
}
.connection-title {
flex: 1;
font-weight: 600;
font-size: 14px;
}
.connection-details {
display: flex;
gap: 16px;
margin: 8px 0;
font-size: 12px;
color: rgba(255, 255, 255, 0.7);
}
.connection-type-label {
background: rgba(100, 200, 255, 0.2);
padding: 2px 8px;
border-radius: 8px;
font-size: 10px;
text-transform: uppercase;
font-weight: 600;
color: #64c8ff;
}
.keywords {
font-style: italic;
}
.connection-actions {
display: flex;
gap: 8px;
margin-top: 12px;
}
.no-connections {
text-align: center;
padding: 40px 20px;
color: rgba(255, 255, 255, 0.6);
}
.no-connections h5 {
margin-bottom: 8px;
color: #64c8ff;
}
/* Tools Tab Styles */
.tools-grid {
display: grid;
grid-template-columns: repeat(2, 1fr);
gap: 12px;
margin-bottom: 24px;
}
.tool-btn {
background: rgba(255, 255, 255, 0.05);
border: 1px solid rgba(100, 200, 255, 0.2);
color: white;
padding: 16px 12px;
border-radius: 12px;
font-size: 12px;
font-weight: 600;
cursor: pointer;
transition: all 0.3s ease;
text-align: center;
}
.tool-btn:hover {
background: rgba(100, 200, 255, 0.1);
border-color: rgba(100, 200, 255, 0.4);
transform: translateY(-2px);
}
.quick-actions {
background: rgba(255, 255, 255, 0.03);
padding: 20px;
border-radius: 12px;
border: 1px solid rgba(100, 200, 255, 0.1);
}
.quick-actions h5 {
margin: 0 0 16px 0;
font-size: 14px;
color: #64c8ff;
}
.quick-actions input {
width: 100%;
background: rgba(255, 255, 255, 0.1);
border: 1px solid rgba(255, 255, 255, 0.2);
color: white;
padding: 12px 16px;
border-radius: 25px;
font-size: 14px;
margin-bottom: 12px;
outline: none;
transition: all 0.3s ease;
}
.quick-actions input:focus {
border-color: #64c8ff;
box-shadow: 0 0 0 3px rgba(100, 200, 255, 0.1);
}
.quick-actions input::placeholder {
color: rgba(255, 255, 255, 0.5);
}
.quick-actions button {
width: 100%;
background: linear-gradient(135deg, #64c8ff 0%, #7877c6 100%);
border: none;
color: white;
padding: 12px;
border-radius: 25px;
font-size: 14px;
font-weight: 600;
cursor: pointer;
transition: all 0.3s ease;
}
.quick-actions button:hover {
transform: translateY(-2px);
box-shadow: 0 8px 25px rgba(100, 200, 255, 0.3);
}
/* Selection Tooltip Styles */
.selection-tooltip {
background: rgba(26, 26, 46, 0.95);
backdrop-filter: blur(20px);
border: 1px solid rgba(100, 200, 255, 0.3);
border-radius: 12px;
padding: 16px;
box-shadow: 0 15px 35px rgba(0, 0, 0, 0.3);
max-width: 280px;
z-index: 1000000;
}
.tooltip-content {
color: white;
}
.tooltip-text {
font-size: 13px;
margin-bottom: 12px;
color: rgba(255, 255, 255, 0.9);
font-style: italic;
}
.tooltip-actions {
display: flex;
gap: 8px;
}
.tooltip-actions button {
background: linear-gradient(135deg, #64c8ff 0%, #7877c6 100%);
border: none;
color: white;
padding: 8px 12px;
border-radius: 16px;
font-size: 11px;
font-weight: 600;
cursor: pointer;
transition: all 0.3s ease;
flex: 1;
}
.tooltip-actions button:hover {
transform: scale(1.05);
box-shadow: 0 4px 12px rgba(100, 200, 255, 0.4);
}
/* Notification Styles */
.ai-aepiot-notification {
position: fixed;
top: 120px;
right: 20px;
background: rgba(26, 26, 46, 0.95);
backdrop-filter: blur(20px);
border: 1px solid;
border-radius: 12px;
padding: 16px;
max-width: 350px;
z-index: 1000001;
display: flex;
align-items: center;
gap: 12px;
box-shadow: 0 15px 35px rgba(0, 0, 0, 0.3);
animation: slideIn 0.4s cubic-bezier(0.4, 0, 0.2, 1);
}
@keyframes slideIn {
from {
transform: translateX(100%);
opacity: 0;
}
to {
transform: translateX(0);
opacity: 1;
}
}
.notification-success {
border-color: #4ade80;
color: #4ade80;
}
.notification-info {
border-color: #64c8ff;
color: #64c8ff;
}
.notification-warning {
border-color: #fbbf24;
color: #fbbf24;
}
.notification-error {
border-color: #f87171;
color: #f87171;
}
.notification-message {
flex: 1;
font-size: 14px;
font-weight: 500;
}
.notification-close {
background: none;
border: none;
color: inherit;
cursor: pointer;
font-size: 18px;
padding: 4px;
border-radius: 50%;
transition: all 0.3s ease;
}
.notification-close:hover {
background: rgba(255, 255, 255, 0.1);
}
/* Responsive Design */
@media (max-width: 768px) {
.ai-aepiot-integration-panel {
width: calc(100vw - 40px);
right: 20px;
left: 20px;
top: 10px;
max-height: calc(100vh - 20px);
}
.tools-grid {
grid-template-columns: 1fr;
}
.processing-stats {
grid-template-columns: 1fr;
gap: 12px;
}
.selection-tooltip {
max-width: calc(100vw - 60px);
left: 30px !important;
right: 30px !important;
width: auto !important;
}
.tooltip-actions {
flex-direction: column;
}
}
/* Animation Enhancements */
.ai-aepiot-integration-panel {
animation: panelSlideIn 0.5s cubic-bezier(0.4, 0, 0.2, 1);
}
@keyframes panelSlideIn {
from {
transform: translateX(100%);
opacity: 0;
}
to {
transform: translateX(0);
opacity: 1;
}
}
.tab-panel.active {
animation: tabFadeIn 0.3s ease;
}
@keyframes tabFadeIn {
from {
opacity: 0;
transform: translateY(10px);
}
to {
opacity: 1;
transform: translateY(0);
}
}
/* Accessibility Improvements */
.ai-aepiot-integration-panel button:focus,
.ai-aepiot-integration-panel input:focus {
outline: 2px solid #64c8ff;
outline-offset: 2px;
}
.ai-aepiot-integration-panel button:focus-visible,
.ai-aepiot-integration-panel input:focus-visible {
outline: 2px solid #64c8ff;
outline-offset: 2px;
}
/* High contrast mode support */
@media (prefers-contrast: high) {
.ai-aepiot-integration-panel {
border: 3px solid #ffffff;
}
.tab-btn.active {
background: #ffffff;
color: #000000;
}
}
/* Reduced motion support */
@media (prefers-reduced-motion: reduce) {
* {
animation-duration: 0.01ms !important;
animation-iteration-count: 1 !important;
transition-duration: 0.01ms !important;
}
}
</style>
`;
document.head.insertAdjacentHTML('beforeend', styles);
}
// ================================
// ADVANCED AI INTEGRATION METHODS
// ================================
initializeSemanticProcessing() {
// Load previously stored semantic memory
this.loadSemanticMemory();
// Setup real-time semantic processing pipeline
this.setupSemanticPipeline();
// Initialize advanced AI features
this.initializeAdvancedAIFeatures();
}
setupSemanticPipeline() {
// Create semantic processing pipeline
this.semanticPipeline = {
input: new Map(),
processing: new Map(),
output: new Map(),
errors: new Map()
};
// Setup pipeline processing
setInterval(() => {
this.processSemanticPipeline();
}, 2000); // Process every 2 seconds
}
processSemanticPipeline() {
// Process items in the semantic pipeline
for (const [id, data] of this.semanticPipeline.input) {
try {
this.semanticPipeline.processing.set(id, Date.now());
// Process semantic data
const processedData = this.enhanceSemanticData(data);
// Move to output
this.semanticPipeline.output.set(id, processedData);
// Clean up
this.semanticPipeline.input.delete(id);
this.semanticPipeline.processing.delete(id);
// Update UI if needed
this.updateSemanticUI(processedData);
} catch (error) {
this.semanticPipeline.errors.set(id, error);
this.semanticPipeline.input.delete(id);
this.semanticPipeline.processing.delete(id);
console.warn('Semantic processing error:', error);
}
}
}
enhanceSemanticData(data) {
// Enhance semantic data with advanced processing
const enhanced = { ...data };
// Add temporal context
enhanced.temporalContext = this.analyzeTemporalContext(data);
// Add cross-references
enhanced.crossReferences = this.findCrossReferences(data);
// Add semantic depth scoring
enhanced.semanticDepth = this.calculateSemanticDepth(data);
// Add aéPiot integration suggestions
enhanced.aepiotSuggestions = this.generateAepiotSuggestions(data);
return enhanced;
}
analyzeTemporalContext(data) {
// Analyze temporal patterns in the conversation
const timeOfDay = new Date().getHours();
const dayOfWeek = new Date().getDay();
return {
timeOfDay: timeOfDay,
dayOfWeek: dayOfWeek,
temporalRelevance: this.calculateTemporalRelevance(data, timeOfDay),
historicalContext: this.findHistoricalContext(data)
};
}
calculateTemporalRelevance(data, timeOfDay) {
// Calculate relevance based on time
let relevance = 1.0;
// Business hours boost for business topics
if (timeOfDay >= 9 && timeOfDay <= 17) {
const businessTopics = data.topics?.filter(t => t.topic === 'business') || [];
if (businessTopics.length > 0) {
relevance += 0.2;
}
}
// Evening boost for educational content
if (timeOfDay >= 18 && timeOfDay <= 22) {
const educationalTopics = data.topics?.filter(t => t.topic === 'education') || [];
if (educationalTopics.length > 0) {
relevance += 0.15;
}
}
return Math.min(relevance, 2.0);
}
findCrossReferences(data) {
// Find cross-references in semantic memory
const crossRefs = [];
data.concepts?.forEach(concept => {
const memoryEntry = this.semanticMemory.get(concept.concept);
if (memoryEntry && memoryEntry.occurrences > 1) {
crossRefs.push({
concept: concept.concept,
previousOccurrences: memoryEntry.occurrences,
previousContexts: memoryEntry.contexts.slice(-3), // Last 3 contexts
relevance: this.calculateCrossRefRelevance(concept, memoryEntry)
});
}
});
return crossRefs.sort((a, b) => b.relevance - a.relevance);
}
calculateSemanticDepth(data) {
// Calculate semantic depth score
let depth = 0;
// Base scoring
depth += (data.topics?.length || 0) * 2;
depth += (data.concepts?.length || 0) * 3;
depth += (data.questions?.length || 0) * 1.5;
depth += (data.entities?.length || 0) * 0.5;
// Complexity bonuses
const complexConcepts = data.concepts?.filter(c => c.concept.includes(' ')) || [];
depth += complexConcepts.length * 2;
// Question complexity bonus
const complexQuestions = data.questions?.filter(q => q.split(' ').length > 8) || [];
depth += complexQuestions.length * 1.5;
return Math.min(depth, 100); // Cap at 100
}
generateAepiotSuggestions(data) {
// Generate intelligent aéPiot integration suggestions
const suggestions = [];
// High-value topic suggestions
data.topics?.filter(t => t.relevance > 0.7).forEach(topic => {
suggestions.push({
type: 'high_value_topic',
topic: topic.topic,
action: 'create_semantic_backlink',
priority: 'high',
url: this.generateAepiotBacklink({
title: `High-Value-${topic.topic}-Analysis`,
description: `Deep semantic analysis of ${topic.topic} with ${topic.relevance} relevance score`,
link: window.location.href
})
});
});
// Complex concept suggestions
const complexConcepts = data.concepts?.filter(c => c.concept.split(' ').length > 1) || [];
complexConcepts.forEach(concept => {
suggestions.push({
type: 'complex_concept',
concept: concept.concept,
action: 'advanced_search',
priority: 'medium',
url: this.generateAepiotAdvancedSearchURL({
query: concept.concept,
language: this.detectLanguage(data.originalText)
})
});
});
// Question exploration suggestions
data.questions?.forEach(question => {
if (question.length > 20) { // Substantial questions only
suggestions.push({
type: 'substantial_question',
question: question,
action: 'question_exploration',
priority: 'medium',
url: this.generateAepiotAdvancedSearchURL({
query: question.replace(/[?]/g, ''),
language: 'en'
})
});
}
});
return suggestions.sort((a, b) => {
const priorityOrder = { high: 3, medium: 2, low: 1 };
return priorityOrder[b.priority] - priorityOrder[a.priority];
});
}
// ================================
// AI SYSTEM SPECIFIC ENHANCEMENTS
// ================================
initializeAdvancedAIFeatures() {
// Initialize AI-specific enhanced features
this.setupAISpecificFeatures();
this.initializeConversationalAI();
this.setupIntelligentSuggestions();
}
setupAISpecificFeatures() {
switch (this.aiSystem) {
case 'claude':
this.initializeClaudeEnhancements();
break;
case 'chatgpt':
this.initializeChatGPTEnhancements();
break;
case 'gemini':
this.initializeGeminiEnhancements();
break;
default:
this.initializeGenericAIEnhancements();
}
}
initializeClaudeEnhancements() {
// Claude-specific enhancements
this.claudeFeatures = {
analysisDepth: 'deep',
contextWindow: 'large',
reasoningCapability: 'high',
specializations: ['analysis', 'research', 'writing', 'coding']
};
// Enhanced prompt suggestions for Claude
this.claudePromptTemplates = [
'Can you analyze the deeper implications of: "{concept}"?',
'What are the interdisciplinary connections to: "{topic}"?',
'How might this evolve in different cultural contexts: "{content}"?',
'What are the ethical considerations around: "{concept}"?',
'Can you break down the complexity of: "{topic}" into fundamental components?'
];
}
initializeChatGPTEnhancements() {
// ChatGPT-specific enhancements
this.chatgptFeatures = {
conversationalStyle: 'natural',
creativityLevel: 'high',
knowledgeBase: 'broad',
specializations: ['conversation', 'creativity', 'explanation', 'problem-solving']
};
// Enhanced prompt suggestions for ChatGPT
this.chatgptPromptTemplates = [
'Explain "{concept}" in an engaging and accessible way',
'What creative applications could "{topic}" have?',
'How would you teach "{content}" to different age groups?',
'What are some innovative approaches to: "{concept}"?',
'Can you create analogies to help understand: "{topic}"?'
];
}
initializeGeminiEnhancements() {
// Gemini-specific enhancements
this.geminiFeatures = {
multimodalCapability: 'high',
searchIntegration: 'native',
realTimeData: 'available',
specializations: ['search', 'multimodal', 'current-events', 'factual-accuracy']
};
// Enhanced prompt suggestions for Gemini
this.geminiPromptTemplates = [
'What are the latest developments in: "{topic}"?',
'Can you fact-check and provide sources for: "{concept}"?',
'How does "{content}" relate to current trends?',
'What visual representations would help explain: "{topic}"?',
'What are experts currently saying about: "{concept}"?'
];
}
initializeGenericAIEnhancements() {
// Generic AI enhancements for unknown systems
this.genericFeatures = {
adaptability: 'high',
learningCapability: 'dynamic',
integrationApproach: 'universal'
};
this.genericPromOfficial aéPiot Domains
- https://headlines-world.com (since 2023)
- https://aepiot.com (since 2009)
- https://aepiot.ro (since 2009)
- https://allgraph.ro (since 2009)
aéPiot AI Integration Script - Complete User Guide
This guide explains the full functionality of the AI integration script for aéPiot, designed for users with external AI systems who do not operate an aéPiot server.
1. Overview
The script provides local tools to:
- Perform semantic analysis of webpage content.
- Generate AI-relevant suggestions and backlink URLs for aéPiot.
- Track and store semantic memory across conversations.
- Provide a rich interactive UI with notifications, tooltips, and tabbed panels.
- Enable cross-linguistic exploration of topics.
2. Semantic Analysis Features
- manualSemanticAnalysis(): Forces semantic analysis of current page text.
- calculateRelevanceScore(analysis): Computes a relevance score based on topics, concepts, questions, and keywords.
- Enhances semantic data by adding:
- Temporal context (time of day, day of week)
- Cross-references from previous semantic memory
- Semantic depth scoring
- aéPiot suggestion links for high-value topics, complex concepts, and substantial questions
3. Backlinks & aéPiot Integration
- generateAepiotBacklink(): Creates a unique URL that points to aéPiot with a title, description, and link.
- User clicks the backlink to access aéPiot with prefilled analysis data.
- createSemanticBacklinkFromSelection(text): Generates a backlink for any selected text on the page.
- No server is required; all links open directly in the browser for user interaction.
4. Cross-Linguistic Analysis
The script can generate searches in multiple languages for the top topics in the current conversation:
- Languages include English, Spanish, French, German, Japanese, Chinese, Romanian, Italian.
- Generates separate aéPiot search URLs for each language automatically.
5. Conversation Context Management
- Updates a local conversation context map with a maximum of 50 entries.
- Tracks topics, concepts, questions, keywords, and timestamps.
- Maintains a semantic memory of concepts with occurrences and contexts.
- Persists semantic memory in
localStoragefor cross-session AI learning.
6. User Interface Components
- Panel with tabbed interface for Live Analysis, Semantic Insights, Connections, and Tools.
- Inline selection tooltips for selected text with options:
- 🔍 Explore in aéPiot
- 🔗 Create Semantic Backlink
- Notifications system with
success,info,warning,errortypes. - Keyboard shortcuts:
- Ctrl+Shift+A: Toggle panel
- Ctrl+Shift+S: Quick semantic analysis
- Ctrl+Shift+E: Export conversation
7. Reporting & Analytics
- compileReport(conversationData): Generates a detailed report including:
- Total messages, topics, concepts, questions, keywords
- Top topics and top concepts
- Language distribution
- aéPiot connection stats and recent links
- generateReportSummary(report): Creates a short human-readable summary of the report.
8. AI System-Specific Enhancements
- Supports multiple AI systems: Claude, ChatGPT, Gemini, or generic AI.
- Each AI system has specialized prompt templates and feature sets.
- Claude: Deep analysis, interdisciplinary insights, ethical considerations.
- ChatGPT: Conversational, creative, explanatory prompts.
- Gemini: Multimodal, real-time data, factual checking, search-integrated prompts.
9. Quick Actions & Tools
- Quick search field for generating an aéPiot advanced search.
- Buttons for exploring concepts, asking questions, and exporting conversation data.
- Tool grid for frequently used AI functions and semantic operations.
10. Accessibility & Responsive Design
- High-contrast mode support
- Reduced-motion mode for animations
- Keyboard focus outlines for all interactive elements
- Responsive layout for smaller screens (mobile, tablet)
11. Notifications & Tooltips
- Selection tooltip appears for text between 5 and 200 characters.
- Tooltips auto-hide after 10 seconds or when user clicks outside.
- Notifications slide in and fade out automatically.
12. Initialization & Setup
- Call
initializeSemanticProcessing()to load memory and setup pipeline. - Semantic pipeline processes input items every 2 seconds.
- Enhances each semantic item with temporal, cross-reference, and depth info before updating UI.
Note: This script operates entirely on the client-side. No server or API access is required. Users with external AI systems can use all features locally, while generating backlinks and search links to aéPiot.
13. Summary
The aéPiot AI integration script provides a full suite of tools for semantic analysis, cross-linguistic exploration, concept and topic enhancement, and generating actionable backlinks for the aéPiot platform. It is designed for local AI environments without the need for a server, providing a rich interactive experience for users, with notifications, tooltips, reports, and AI system-specific prompt suggestions.
https://medium.com/@global.audiences/universal-ai-a%C3%A9piot-integration-system-624f823e6812
