Matched Plugins with Avatar Base

Unreal/Plugins/AvatarCore_AI/Source/AvatarCore_AI/Private/AIBaseManager.cpp

@@ -434,6 +434,11 @@ void UAIBaseManager::OnRequestTimeout()
     SetNewState(EAvatarCoreAIState::Error);
 }
 
+UMCPBaseManager* UAIBaseManager::GetMCPManager()
+{
+    return MCPManager;
+}
+
 // MCP Event Handler Implementations
 void UAIBaseManager::OnMCPLogReceived(const FString& LogMessage)
 {

Unreal/Plugins/AvatarCore_AI/Source/AvatarCore_AI/Public/AIBaseManager.h

@@ -17,6 +17,7 @@ DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnAIError, FString, ErrorMessage,
 DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FMulticastDelegateRealtimeAPIAudioChunk, const TArray<uint8>, PCMData, bool, IsFinal);
 DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnAIDelayedAnswer);
 
+class UMCPManager;
 
 UCLASS(Abstract, Blueprintable, BlueprintType)
 class AVATARCORE_AI_API UAIBaseManager : public UObject
@@ -154,6 +155,10 @@ public:
     UFUNCTION()
     void OnRequestTimeout();
 
+    // Add a command at runtime (handles AddToRoot)
+    UFUNCTION(BlueprintCallable, Category = "AvatarCoreAI|MCP")
+    UMCPBaseManager* GetMCPManager();
+
     // Add a command at runtime (handles AddToRoot)
     UFUNCTION(BlueprintCallable, Category = "AvatarCoreAI|MCP Commands")
     void AddUnrealCommand(UMCPUnrealCommand* Command);

Unreal/Plugins/AvatarCore_AI/Source/AvatarCore_AI/Public/RealtimeAPI/AvatarCoreAIRealtime.h

@@ -95,22 +95,22 @@ struct FOpenAIRateLimit
 	GENERATED_USTRUCT_BODY()
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite)
-	int32 requestsLimit;
+	int32 requestsLimit = 0;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite)
-	int32 requestsRemaining;
+	int32 requestsRemaining = 0;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite)
-	int32 requestsResetTimeRemaining;
+	int32 requestsResetTimeRemaining = 0;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite)
-	int32 tokensLimit;
+	int32 tokensLimit = 0;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite)
-	int32 tokensRemaining;
+	int32 tokensRemaining = 0;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite)
-	int32 tokensResetTimeRemaining;
+	int32 tokensResetTimeRemaining = 0;
 };
 
 DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FMulticastDelegateRealtimeAPIMessageReceived, FString, ReceivedMessage);

Unreal/Plugins/AvatarCore_AI/Source/ThirdParty/MCPServer/FastMCP/AddDocumentsToDatabase.py

@@ -1,10 +1,20 @@
 # setup_db.py
 import os
+import re
 from document_vectordb import DocumentVectorDB
+from colorama import Fore
+
+def _sanitize_table_name(name: str) -> str:
+    name = name.strip().lower()
+    name = re.sub(r'[^a-z0-9]+', '_', name)
+    name = name.strip('_')
+    if not name:
+        return "documents"
+    return name
 
 
 def setup_database():
-    print("Initializing database...")
+    print(Fore.GREEN + "Initializing database...")
     db = DocumentVectorDB()
     db.create_table()
     
@@ -15,30 +25,44 @@ def setup_database():
     
     if not os.path.exists(document_add_folder):
         os.makedirs(document_add_folder)
-        print(f"Created {document_add_folder} directory. Please add your PDF/text files there.")
+        print(Fore.GREEN + f"Created {document_add_folder} directory. Please add your PDF/text files there.")
         return
     if not os.path.exists(document_added_folder):
         os.makedirs(document_added_folder)
     
     files_added = 0
-    for filename in os.listdir(document_add_folder):
-        if filename.endswith(('.pdf', '.txt')):
-            file_path = os.path.join(document_add_folder, filename)
-            copy_file_path = os.path.join(document_added_folder, filename)
-            print(f"Adding {filename}...")
-            try:
-                db.add_document(file_path)
-                files_added += 1
-                os.rename(file_path, copy_file_path)
-            except Exception as e:
-                print(f"Error adding {filename}: {e}")
+    for root, dirs, files in os.walk(document_add_folder):
+        rel_root = os.path.relpath(root, document_add_folder)
+        if rel_root == ".":
+            current_table = "documents"
+        else:
+            first_folder = rel_root.split(os.sep)[0]
+            current_table = _sanitize_table_name(first_folder)
+        for filename in files:
+            if filename.endswith(('.pdf', '.txt')):
+                file_path = os.path.join(root, filename)
+                if rel_root == ".":
+                    target_root = document_added_folder
+                else:
+                    target_root = os.path.join(document_added_folder, rel_root)
+                if not os.path.exists(target_root):
+                    os.makedirs(target_root)
+                copy_file_path = os.path.join(target_root, filename)
+                print(Fore.GREEN +f"Adding {file_path} to table {current_table}...")
+                try:
+                    db.add_document(file_path, table_name=current_table)
+                    files_added += 1
+                    os.rename(file_path, copy_file_path)
+                except Exception as e:
+                    print(Fore.RED + f"Error adding {file_path}: {e}")
     
     db.finalize_db()
-    print(f"Database setup complete! Added {files_added} documents.")
+    print(Fore.GREEN + f"Database setup complete! Added {files_added} documents.")
     
     # Show stats
     stats = db.get_stats()
-    print(f"Database stats: {stats}")
+    print(Fore.GREEN + f"Database stats: {stats}")
+
 
 if __name__ == "__main__":
     setup_database()

Unreal/Plugins/AvatarCore_AI/Source/ThirdParty/MCPServer/FastMCP/FastMCPServer.py

@@ -2,6 +2,8 @@ from fastmcp import FastMCP
 from typing import List, Dict, Any
 from document_vectordb import DocumentVectorDB
 import json
+import re
+
 
 mcp = FastMCP("AvatarCoreMCP_1_0", stateless_http=True)
 
@@ -10,10 +12,14 @@ db = DocumentVectorDB()
 db.create_table()
 
 @mcp.tool()
-def search_information_in_database(query: str) -> List[Dict[str, Any]]:
-    """If you need more information search this database."""
+def search_information(query: str) -> List[Dict[str, Any]]:
+    """If you need more information about search this database."""
     try:
-        results = db.search(query, 10, True, 48, 12) #Boolean for Cuda based ReRanking
+        query = re.sub('Green Hydrogen Hub Stuttgart', '', query)
+        query = re.sub('Green Hydrogen Hub', '', query)
+        query = re.sub('GHH', '', query)
+        print(query)
+        results = db.search(query, 3,"documents", True, 48, 12) #Boolean for Cuda based ReRanking
         return results
     except Exception as e:
         return [{"error": f"Search failed: {str(e)}"}]

Unreal/Plugins/AvatarCore_AI/Source/ThirdParty/MCPServer/FastMCP/TestSearchDatabase.py

@@ -2,11 +2,15 @@ from document_vectordb import DocumentVectorDB
 import traceback
 import time
 
+table = "documents"
+
 def DoSearch():
+    global table
     print("-------------------------", flush=True)
+    print(f'Which table to search? (empty for {table})', flush=True)
+    table = input() or table
     print('What do you wanna search?', flush=True)
     query = input()
-    #query = "Usability 101"
 
     if query == "":
         exit();
@@ -14,7 +18,7 @@ def DoSearch():
     try:
         start_time = time.time()
         print("Calling db.search...", flush=True)
-        results = db.search(query, limit=10, rerank=True, candidates=48, batch_size=12)
+        results = db.search(query, limit=3, table_name=table, rerank=True, candidates=48, batch_size=12)
         print(f"db.search returned list of length: {len(results) if results is not None else 'None'}", flush=True)
     except Exception as e:
         print("Search raised an exception:", flush=True)

Unreal/Plugins/AvatarCore_AI/Source/ThirdParty/MCPServer/FastMCP/WipeDatabase.bat

@@ -1,7 +1,8 @@
 @echo off
 cd /d "%~dp0"
-robocopy documents_added documents_to_add /MOV
+robocopy documents_added documents_to_add /MOV /S
 rmdir /S /Q lancedb
+rmdir /S /Q documents_added
 echo -----------------------------------------
 echo Farewall, my old friend!
 echo -----------------------------------------

Unreal/Plugins/AvatarCore_AI/Source/ThirdParty/MCPServer/FastMCP/document_vectordb.py

@@ -2,10 +2,13 @@ import lancedb
 import pandas as pd
 from sentence_transformers import SentenceTransformer
 from sentence_transformers import CrossEncoder
-import PyPDF2
+from pdfminer.high_level import extract_text
+from langchain_text_splitters import RecursiveCharacterTextSplitter
 import pyarrow as pa
 import os
 import torch
+import time
+from colorama import Fore
 from typing import List, Dict
 import re
 from hashlib import sha1
@@ -14,11 +17,17 @@ class DocumentVectorDB:
     def __init__(self, db_path: str = "./lancedb"):
         self.db = lancedb.connect(db_path)
         # Model will be initialized in create_table() based on table vector dimension
+        
+        #Debug Variables
+        self.start_time = None
+        self.end_time = None
+        
         self.model = None
         self.model_dim = None
         self.model_name = None
         self.table_name = "documents"
-        self.reranker = None  # lazy
+        self.reranker = None
+        self._load_reranker()
 
     def _load_reranker(self, model_name: str = "cross-encoder/ms-marco-MiniLM-L-6-v2"):
         if self.reranker is None:
@@ -63,17 +72,11 @@ class DocumentVectorDB:
         # Default if undetectable
         return 384
 
-    def create_table(self):
-        # Create table schema
-        schema = {
-            "id": str,
-            "content": str,
-            "source": str,
-            "vector": list
-        }
-
-        # Create empty table if it doesn't exist
-        if self.table_name not in self.db.table_names():
+    def _ensure_table(self, table_name: str):
+        if getattr(self, "table", None) is not None and self.table_name == table_name and self.model is not None:
+            return
+        self.table_name = table_name
+        if table_name not in self.db.table_names():
             # Initialize a default 384-d model for a fresh table
             self._load_model_for_dim(384)
             emb_dim = self.model.get_sentence_embedding_dimension()
@@ -86,61 +89,95 @@ class DocumentVectorDB:
                 "doc_id": "sample.txt",
                 "chunk_index": 0
             }])
-            self.table = self.db.create_table(self.table_name, sample_data)
+            self.table = self.db.create_table(table_name, sample_data)
             # Delete the sample data
             self.table.delete("id = 'sample'")
         else:
-            self.table = self.db.open_table(self.table_name)
+            self.table = self.db.open_table(table_name)
             # Infer vector dimension from existing table and load matching model
             dim = self._infer_table_vector_dim()
             self._load_model_for_dim(dim)
 
+    def create_table(self, table_name: str = "documents"):
+        # Create table schema
+        schema = {
+            "id": str,
+            "content": str,
+            "source": str,
+            "vector": list
+        }
+        self._ensure_table(table_name)
+
+    def _create_index_for_current_table(self):
+        try:
+            row_count = self.table.count_rows()
+        except Exception:
+            row_count = 0
+
+        if row_count < 100:
+            return
+
+        if row_count < 1000:
+            num_partitions = 1
+            num_sub_vectors = 8
+        elif row_count < 10000:
+            num_partitions = 8
+            num_sub_vectors = 16
+        elif row_count < 100000:
+            num_partitions = 32
+            num_sub_vectors = 64
+        else:
+            num_partitions = 90
+            num_sub_vectors = 96
+
+        try:
+            self.table.create_index(
+                vector_column_name="vector",
+                index_type="IVF_PQ",
+                metric="cosine",
+                num_partitions=num_partitions,
+                num_sub_vectors=num_sub_vectors
+            )
+        except Exception:
+            pass
+
+    def clean_extracted_text(self, text: str) -> str:
+        """
+        Cleans up common PDF extraction artifacts:
+        1. Removes line-break hyphens.
+        2. Replaces excessive whitespace and newlines.
+        """
+
+        text = re.sub(r'([a-z])-(\n\s*)(\n?)', r'\1', text, flags=re.IGNORECASE)
+        text = re.sub(r'\s+', ' ', text).strip()
+
+        return text
+
     def extract_text_from_pdf(self, pdf_path: str) -> str:
         text = ""
-        with open(pdf_path, 'rb') as file:
-            pdf_reader = PyPDF2.PdfReader(file)
-            for page in pdf_reader.pages:
-                text += page.extract_text() or ""
-        return text
+        # pdfminer.six is often more tolerant of broken PDF structure
+        try:
+            text = self.clean_extracted_text(extract_text(pdf_path))
+            return text
+        except Exception as e:
+            print(f"pdfminer.six failed on {pdf_path}: {e}")
+            return "" # Or try pypdf as a fallback here
+
+    def chunk_text(self, text: str, chunk_size: int = 512, overlap: int = 50) -> List[str]:
+        # Use characters (tokens) for chunking, not just words
+        splitter = RecursiveCharacterTextSplitter(
+            chunk_size=512,  # Set chunk size to token/char count, not word count
+            chunk_overlap=50,
+            length_function=len,  # Use character length
+            separators=["\n\n", "\n", ". ", " ", ""] # Hierarchical splitting
+        )
+        # The splitters are highly optimized and handle the logic efficiently
+        chunks = splitter.split_text(text)
+        return chunks
 
-    def chunk_text(self, text: str, chunk_size: int = 150, overlap: int = 25) -> List[str]:
-        sentences = re.split(r'(?<=[\.\!\?])\s+', text.strip()) if text else []
-        chunks = []
-        current = []
-        current_len = 0
-        for s in sentences:
-            w = s.split()
-            if current_len + len(w) > chunk_size and current:
-                chunks.append(' '.join(current))
-                if overlap > 0 and chunks:
-                    back = []
-                    words_acc = 0
-                    for sent in reversed(current):
-                        ws = sent.split()
-                        if words_acc + len(ws) > overlap:
-                            break
-                        back.insert(0, sent)
-                        words_acc += len(ws)
-                    current = back
-                    current_len = sum(len(x.split()) for x in current)
-                else:
-                    current = []
-                    current_len = 0
-            current.append(s)
-            current_len += len(w)
-        if current:
-            chunks.append(' '.join(current))
-        return [c for c in chunks if c.strip()]
-
-    def add_document(self, file_path: str, doc_type: str = "auto"):
+    def add_document(self, file_path: str, doc_type: str = "auto", table_name: str = "documents"):
         # Ensure model is initialized (in case add_document is used without create_table())
-        if self.model is None:
-            if self.table_name in self.db.table_names():
-                self.table = self.db.open_table(self.table_name)
-                dim = self._infer_table_vector_dim()
-                self._load_model_for_dim(dim)
-            else:
-                self._load_model_for_dim(384)
+        self._ensure_table(table_name)
 
         # Extract text based on file type
         if doc_type == "auto":
@@ -155,6 +192,9 @@ class DocumentVectorDB:
         # Chunk the text
         chunks = self.chunk_text(text)
 
+        print(Fore.GREEN + f"{len(chunks)} chunks added.")
+        print(Fore.BLUE + chunks[0])
+
         # Create embeddings and store
         data_to_add = []
         if chunks:
@@ -166,6 +206,8 @@ class DocumentVectorDB:
             )
             base = os.path.basename(file_path)
             for i, (chunk, emb) in enumerate(zip(chunks, embeddings)):
+                if len(chunk) < 1:
+                    continue 
                 did = sha1(f"{base}|{i}|{len(chunk)}".encode("utf-8")).hexdigest()[:16]
                 doc_data = {
                     "id": did,
@@ -181,30 +223,21 @@ class DocumentVectorDB:
         if data_to_add:
             df = pd.DataFrame(data_to_add)
             self.table.add(df)
-            try:
-                self.table.create_index(metric="cosine", num_partitions=90, num_sub_vectors=96)
-            except Exception:
-                pass
+            self._create_index_for_current_table()
 
     def finalize_db(self):
-        self.table.create_index(
-            vector_column_name="vector",     # or your actual vector column name
-            index_type="IVF_PQ",
-            metric="cosine",
-            num_partitions=90,     # tune by data size
-            num_sub_vectors=96      # tune by recall/latency
-        )
+        self._create_index_for_current_table()
         
-    def search(self, query: str, limit: int = 5, rerank: bool = False, candidates: int = 100, batch_size: int = 64) -> List[Dict]:
-        # Ensure model is initialized
-        if self.model is None:
-            if self.table_name in self.db.table_names():
-                self.table = self.db.open_table(self.table_name)
-                dim = self._infer_table_vector_dim()
-                self._load_model_for_dim(dim)
-            else:
-                self._load_model_for_dim(384)
+    def DebugTimeIt(self, TimedLabel=""):
+        if self.start_time is not None:
+            self.end_time = time.time()
+            elapsed_time = self.end_time - self.start_time
+            print(f"{TimedLabel}: Elapsed time {elapsed_time}")
+        self.start_time = time.time()
 
+    def search(self, query: str, limit: int = 5, table_name: str = "documents", rerank: bool = False, candidates: int = 100, batch_size: int = 64) -> List[Dict]:
+        # Ensure model is initialized
+        self._ensure_table(table_name)
         query_embedding = self.model.encode(query, normalize_embeddings=True).tolist()
         
         if rerank:
@@ -217,6 +250,7 @@ class DocumentVectorDB:
                 .limit(candidates)
                 .to_pandas()
             )
+            
             if raw is None or raw.empty:
                 return []
 
@@ -288,15 +322,46 @@ class DocumentVectorDB:
 
     def get_stats(self) -> Dict:
         try:
-            count = self.table.count_rows()
+            tables_info = []
+            table_names = list(self.db.table_names())
+
+            old_table = getattr(self, "table", None)
+            old_table_name = getattr(self, "table_name", None)
+
+            for name in table_names:
+                try:
+                    tbl = self.db.open_table(name)
+                    self.table = tbl
+                    self.table_name = name
+                    count = tbl.count_rows()
+                    vector_dim = self._infer_table_vector_dim()
+                    tables_info.append({
+                        "table_name": name,
+                        "total_chunks": count,
+                        "vector_dim": vector_dim,
+                    })
+                except Exception as inner_e:
+                    tables_info.append({
+                        "table_name": name,
+                        "error": str(inner_e),
+                    })
+
+            if old_table is not None:
+                self.table = old_table
+            if old_table_name is not None:
+                self.table_name = old_table_name
+
             return {
                 "lancedb_version": lancedb.__version__,
                 "pyarrow_version": pa.__version__,
                 "torch_version": torch.__version__,
-                "total_chunks": count,
-                "table_name": self.table_name,
-                "model": self.model_name,
-                "vector_dim": self.model_dim,
+                "tables": tables_info,
             }
         except Exception as e:
             return {"error": str(e)}
+
+    def get_tables(self) -> List[str]:
+        try:
+            return list(self.db.table_names())
+        except Exception:
+            return []

Unreal/Plugins/AvatarCore_AI/Source/ThirdParty/MCPServer/FastMCP/requirements.txt

@@ -8,7 +8,7 @@ fastmcp==2.10.6
 lancedb==0.25.3
 pandas==2.3.1
 sentence-transformers==5.1.0
-PyPDF2==3.0.1
+pdfminer.six==20251107
 torch==2.9.0+cu128
 transformers==4.55.0
 huggingface-hub==0.34.4
@@ -28,4 +28,5 @@ httpx==0.28.1
 httpx-sse==0.4.1
 pydantic==2.11.7
 pydantic-settings==2.10.1
+langchain-text-splitters==1.0.0
 PyYAML==6.0.2

Unreal/Plugins/AvatarCore_Manager/Source/AvatarCore_Manager/AvatarCore_Manager.Build.cs

@@ -25,7 +25,8 @@ public class AvatarCore_Manager : ModuleRules
 		PublicDependencyModuleNames.AddRange(
 			new string[]
 			{
-				"Core"
+				"Core",
+                "GameplayTags"
 				// ... add other public dependencies that you statically link with here ...
 			}
 			);
@@ -40,7 +41,8 @@ public class AvatarCore_Manager : ModuleRules
 				"SlateCore",
                 "AvatarCore_TTS",
                 "AvatarCore_STT",
-                "AvatarCore_AI"
+                "AvatarCore_AI",
+                "DeveloperSettings"
 				// ... add private dependencies that you statically link with here ...	
 			}
 			);

Unreal/Plugins/AvatarCore_Manager/Source/AvatarCore_Manager/Private/AvatarCoreSettings.cpp

@@ -0,0 +1,9 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "AvatarCoreSettings.h"
+
+UAvatarCoreSettings::UAvatarCoreSettings(const FObjectInitializer& ObjectInitializer)
+{
+	
+}

Unreal/Plugins/AvatarCore_Manager/Source/AvatarCore_Manager/Private/AvatarCore_Manager.cpp

@@ -1,5 +1,7 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
 
+#include "AvatarCoreSettings.h"
+#include "Developer/Settings/Public/ISettingsModule.h"
 #include "AvatarCore_Manager.h"
 
 #define LOCTEXT_NAMESPACE "FAvatarCore_ManagerModule"
@@ -7,6 +9,15 @@
 void FAvatarCore_ManagerModule::StartupModule()
 {
 	// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
+	ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
+	if (SettingsModule)
+	{
+		SettingsModule->RegisterSettings("Project", "Plugins", "Avatar Core Manager",
+			LOCTEXT("RuntimeSettingsName", "AvatarCoreManager"),
+			LOCTEXT("RuntimeSettingsDescription", "Configure the Avatar Core Manager plug-in"),
+			GetMutableDefault<UAvatarCoreSettings>()
+		);
+	}
 }
 
 void FAvatarCore_ManagerModule::ShutdownModule()

Unreal/Plugins/AvatarCore_Manager/Source/AvatarCore_Manager/Public/AvatarCoreSettings.h

@@ -0,0 +1,23 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "UObject/NoExportTypes.h"
+#include "GameplayTagContainer.h"
+#include "AvatarCoreSettings.generated.h"
+
+/**
+ * 
+ */
+UCLASS(config = Engine, defaultconfig)
+class AVATARCORE_MANAGER_API UAvatarCoreSettings : public UDeveloperSettings
+{
+	GENERATED_BODY()
+
+public:
+	explicit UAvatarCoreSettings(const FObjectInitializer& ObjectInitializer);
+
+	UPROPERTY(Config, EditAnywhere, Category = "AvatarCoreSettings", meta = (ConfigRestartRequired = true, ToolTip = "All available states of this project."))
+	TArray<FGameplayTag> States;
+};