Feature/ia

.sonarlint/connectedMode.json

@@ -0,0 +1,5 @@
+{
+    "sonarCloudOrganization": "omics-datascience",
+    "projectKey": "omics-datascience_multiomix",
+    "region": "EU"
+}

config/requirements.txt

@@ -29,4 +29,11 @@ statsmodels==0.14.2
 xlrd==2.0.1
 openpyxl==3.1.5
 rpy2==3.6.1
-urllib3==2.5.0
+urllib3==2.5.0
+langchain>=0.3.0
+langchain-openai>=0.2.0
+langchain-community>=0.3.0
+langchain-huggingface>=0.1.0
+pgvector>=0.3.6
+sentence-transformers>=3.0.0
+openai>=1.50.0

docker-compose.dev.yml

@@ -1,7 +1,7 @@
 services:
     # PostgreSQL
     db:
-        image: postgres:16
+        image: pgvector/pgvector:pg16
         restart: 'always'
         container_name: multiomics_dev_db
         ports:

src/assistant/admin.py

@@ -0,0 +1,39 @@
+from django.contrib import admin
+from .models import Conversation, Message, CuratedDocument
+
+
+@admin.register(CuratedDocument)
+class CuratedDocumentAdmin(admin.ModelAdmin):
+    list_display = ['title', 'category', 'is_active', 'updated_at']
+    list_filter = ['is_active', 'category']
+    search_fields = ['title', 'content']
+
+    def save_model(self, request, obj, form, change):
+        """Auto-generate embedding when saving a CuratedDocument."""
+        super().save_model(request, obj, form, change)
+        try:
+            from assistant.services.embedding_service import embedding_service
+            text = f'{obj.title}\n{obj.content}'
+            obj.embedding = embedding_service.embed(text)
+            CuratedDocument.objects.filter(pk=obj.pk).update(embedding=obj.embedding)
+        except Exception as e:
+            self.message_user(request, f'Warning: could not generate embedding: {e}', level='warning')
+
+
+@admin.register(Conversation)
+class ConversationAdmin(admin.ModelAdmin):
+    list_display = ['id', 'user', 'title', 'created_at', 'updated_at']
+    list_filter = ['user']
+    search_fields = ['title', 'user__username']
+    readonly_fields = ['created_at', 'updated_at']
+
+
+@admin.register(Message)
+class MessageAdmin(admin.ModelAdmin):
+    list_display = ['id', 'conversation', 'role', 'content_preview', 'created_at']
+    list_filter = ['role']
+    readonly_fields = ['created_at', 'embedding']
+
+    def content_preview(self, obj):
+        return obj.content[:80]
+    content_preview.short_description = 'Content'

src/assistant/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class AssistantConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'assistant'

src/assistant/migrations/0001_initial.py

@@ -0,0 +1,71 @@
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import pgvector.django
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.RunSQL(
+            sql='CREATE EXTENSION IF NOT EXISTS vector;',
+            reverse_sql='DROP EXTENSION IF EXISTS vector;',
+        ),
+        migrations.CreateModel(
+            name='Conversation',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('title', models.CharField(blank=True, max_length=200, null=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('user', models.ForeignKey(
+                    on_delete=django.db.models.deletion.CASCADE,
+                    related_name='conversations',
+                    to=settings.AUTH_USER_MODEL,
+                )),
+            ],
+            options={
+                'ordering': ['-updated_at'],
+            },
+        ),
+        migrations.CreateModel(
+            name='Message',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('role', models.CharField(
+                    choices=[('user', 'User'), ('assistant', 'Assistant')],
+                    max_length=10,
+                )),
+                ('content', models.TextField()),
+                ('embedding', pgvector.django.VectorField(blank=True, dimensions=384, null=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('conversation', models.ForeignKey(
+                    on_delete=django.db.models.deletion.CASCADE,
+                    related_name='messages',
+                    to='assistant.conversation',
+                )),
+            ],
+            options={
+                'ordering': ['created_at'],
+            },
+        ),
+        migrations.CreateModel(
+            name='CuratedDocument',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('title', models.CharField(max_length=300)),
+                ('content', models.TextField()),
+                ('category', models.CharField(blank=True, max_length=100, null=True)),
+                ('embedding', pgvector.django.VectorField(blank=True, dimensions=384, null=True)),
+                ('is_active', models.BooleanField(default=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+            ],
+        ),
+    ]

src/assistant/models.py

@@ -0,0 +1,47 @@
+from django.contrib.auth.models import User
+from django.db import models
+from pgvector.django import VectorField
+
+
+class Conversation(models.Model):
+    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='conversations')
+    title = models.CharField(max_length=200, null=True, blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        ordering = ['-updated_at']
+
+    def __str__(self):
+        return self.title or f'Conversation {self.pk}'
+
+
+class Message(models.Model):
+    class Role(models.TextChoices):
+        USER = 'user', 'User'
+        ASSISTANT = 'assistant', 'Assistant'
+
+    conversation = models.ForeignKey(Conversation, on_delete=models.CASCADE, related_name='messages')
+    role = models.CharField(max_length=10, choices=Role.choices)
+    content = models.TextField()
+    embedding = VectorField(dimensions=384, null=True, blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        ordering = ['created_at']
+
+    def __str__(self):
+        return f'{self.role}: {self.content[:50]}'
+
+
+class CuratedDocument(models.Model):
+    title = models.CharField(max_length=300)
+    content = models.TextField()
+    category = models.CharField(max_length=100, null=True, blank=True)
+    embedding = VectorField(dimensions=384, null=True, blank=True)
+    is_active = models.BooleanField(default=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return self.title

src/assistant/serializers.py

@@ -0,0 +1,22 @@
+from rest_framework import serializers
+from .models import Conversation, Message
+
+
+class MessageSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Message
+        fields = ['id', 'role', 'content', 'created_at']
+
+
+class ConversationSerializer(serializers.ModelSerializer):
+    messages = MessageSerializer(many=True, read_only=True)
+
+    class Meta:
+        model = Conversation
+        fields = ['id', 'title', 'created_at', 'updated_at', 'messages']
+
+
+class ConversationListSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Conversation
+        fields = ['id', 'title', 'created_at', 'updated_at']

src/assistant/services/embedding_service.py

@@ -0,0 +1,53 @@
+from typing import List, Optional
+from django.conf import settings
+
+
+class EmbeddingService:
+    """Singleton lazy-loader for HuggingFace sentence-transformers embeddings."""
+
+    _instance: Optional['EmbeddingService'] = None
+    _model = None
+
+    def __new__(cls) -> 'EmbeddingService':
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def _get_model(self):
+        if self._model is None:
+            import os
+            from langchain_huggingface import HuggingFaceEmbeddings
+
+            # Use HF_TOKEN if provided, otherwise run fully offline (model cached locally).
+            # Inference always runs locally — no text data is ever sent to HuggingFace.
+            hf_token = os.getenv('HF_TOKEN') or None
+            local_only = not hf_token and self._is_cached(settings.ASSISTANT_EMBEDDING_MODEL)
+
+            self._model = HuggingFaceEmbeddings(
+                model_name=settings.ASSISTANT_EMBEDDING_MODEL,
+                model_kwargs={'device': 'cpu'},
+                encode_kwargs={'normalize_embeddings': True},
+                cache_folder=os.getenv('HF_CACHE_DIR', None),
+                **({"huggingface_api_token": hf_token} if hf_token else {}),
+            )
+            # Silence future hub warnings once the model is loaded
+            os.environ.setdefault('TOKENIZERS_PARALLELISM', 'false')
+        return self._model
+
+    @staticmethod
+    def _is_cached(model_name: str) -> bool:
+        """Check if the model weights are already in the local HuggingFace cache."""
+        import os
+        cache_dir = os.getenv('HF_HOME', os.path.expanduser('~/.cache/huggingface'))
+        model_slug = model_name.replace('/', '--')
+        hub_path = os.path.join(cache_dir, 'hub', f'models--{model_slug}')
+        return os.path.isdir(hub_path)
+
+    def embed(self, text: str) -> List[float]:
+        return self._get_model().embed_query(text)
+
+    def embed_many(self, texts: List[str]) -> List[List[float]]:
+        return self._get_model().embed_documents(texts)
+
+
+embedding_service = EmbeddingService()