django-spire 0.21.1__py3-none-any.whl → 0.22.0__py3-none-any.whl

django_spire/consts.py

@@ -1,4 +1,4 @@
-__VERSION__ = '0.21.1'
+__VERSION__ = '0.22.0'
 
 MAINTENANCE_MODE_SETTINGS_NAME = 'MAINTENANCE_MODE'
 

django_spire/core/{tags → tag}/intelligence/tag_set_bot.py

@@ -13,10 +13,11 @@ class TagSetBot(Bot):
         Prompt()
         .list([
             'Make sure to have enough tags to properly cover all the provided content.',
-            'Focus on tagging the words in the content',
-            'Only add additional words that are very relevant to the content.'
-            'Use spaces to separate words in tags',
-            'Include known acronyms along with the full tags.',
+            'Include tags that help searchability.',
+            'Focus on tagging the words in the content.',
+            'Only add additional words that are very relevant to the content.',
+            'Use spaces to separate words in tags.',
+            'Include common acronyms in addition to the tags.',
         ])
     )
 

django_spire/core/tag/mixins.py

@@ -0,0 +1,23 @@
+from django.db import models
+
+from django_spire.core.tag.models import Tag
+from django_spire.core.tag.tools import simplify_and_weight_tag_set_to_dict, simplify_tag_set
+
+
+class TagModelMixin(models.Model):
+    tags = models.ManyToManyField(Tag, related_name='+', null=True, blank=True, editable=False)
+
+    class Meta:
+        abstract = True
+
+    @property
+    def tag_set(self) -> set[str]:
+        return set(self.tags.values_list('name', flat=True))
+
+    @property
+    def simplified_tag_set(self) -> set[str]:
+        return simplify_tag_set(self.tag_set)
+
+    @property
+    def simplified_and_weighted_tag_dict(self) -> dict[str, int]:
+        return simplify_and_weight_tag_set_to_dict(self.tag_set)

django_spire/core/{tags → tag}/models.py

@@ -3,7 +3,7 @@ from typing import Sequence, Self
 from django.db import models
 from django.utils.text import slugify
 
-from django_spire.core.tags.querysets import TagQuerySet
+from django_spire.core.tag.querysets import TagQuerySet
 
 
 class Tag(models.Model):

django_spire/core/tag/service/tag_service.py

@@ -0,0 +1,72 @@
+from abc import abstractmethod, ABC
+from typing import Generic
+
+from django.db.models import QuerySet
+
+from django_spire.contrib.constructor.django_model_constructor import TypeDjangoModel
+from django_spire.contrib.service import BaseDjangoModelService
+from django_spire.core.tag import tools
+from django_spire.core.tag.models import Tag
+from django_spire.core.tag.tools import get_score_percentage_from_tag_set_weighted
+
+
+class BaseTagService(
+    BaseDjangoModelService[TypeDjangoModel],
+    ABC,
+    Generic[TypeDjangoModel]
+):
+    obj: TypeDjangoModel
+
+    @abstractmethod
+    def process_and_set_tags(self):
+        raise NotImplementedError
+
+    def add_tags_from_tag_set(self, tag_set: set[str]):
+        self._update_global_tags_from_set(tag_set)
+
+        self.obj.tags.add(*Tag.objects.in_tag_set(tag_set))
+
+    def clear_tags(self):
+        self.obj.tags.clear()
+
+    def get_matching_tags_from_tag_set(self, tag_set: set[str]) -> QuerySet:
+        return self.obj.tags.in_tag_set(tag_set)
+
+    def get_matching_percentage_of_tag_set(self, tag_set: set[str]) -> float:
+        return tools.get_matching_a_percentage_from_tag_sets(tag_set, self.obj.tag_set)
+
+    def get_matching_percentage_of_model_tags_from_tag_set(self, tag_set: set[str]) -> float:
+        return tools.get_matching_b_percentage_from_tag_sets(tag_set, self.obj.tag_set)
+
+    def get_score_percentage_from_tag_set_weighted(self, tag_set: set[str]) -> float:
+        return get_score_percentage_from_tag_set_weighted(
+            tag_set_actual=tag_set,
+            tag_set_reference=self.obj.tag_set
+        )
+
+    def get_simplified_and_weighted_tag_dict_above_minimum(self, minimum_weight: int = 1) -> dict[str, int]:
+        above_minimum_tag_dict = self.obj.simplified_and_weighted_tag_dict
+
+        return {
+            tag: weight
+            for tag, weight in above_minimum_tag_dict.items()
+            if weight >= minimum_weight
+        }
+
+    def has_tags_in_tag_set(self, tag_set: set[str]) -> bool:
+        return self.obj.tag_set.issuperset(tag_set)
+
+    def remove_tags_by_tag_set(self, tag_set: set[str]):
+        tag_objects = Tag.objects.in_tag_set(tag_set)
+
+        self.obj.tags.remove(*tag_objects)
+
+    def set_tags_from_tag_set(self, tag_set: set[str]):
+        self._update_global_tags_from_set(tag_set)
+
+        tag_objects = Tag.objects.in_tag_set(tag_set)
+        self.obj.tags.set(tag_objects)
+
+    @staticmethod
+    def _update_global_tags_from_set(tag_set: set[str]):
+        Tag.add_tags([Tag(name=tag) for tag in tag_set])

django_spire/core/{tags → tag}/tests/test_intelligence.py

@@ -1,6 +1,6 @@
 from unittest import TestCase
 
-from django_spire.core.tags.intelligence.tag_set_bot import TagSetBot
+from django_spire.core.tag.intelligence.tag_set_bot import TagSetBot
 
 TEST_INPUT = """
     I love reading books about science fiction, fantasy, and adventure, especially ones

django_spire/core/tag/tests/test_tags.py

@@ -0,0 +1,102 @@
+from django.test import TestCase
+
+from django_spire.core.tag.models import Tag
+from django_spire.knowledge.collection.models import Collection
+
+
+class TestTags(TestCase):
+    def setUp(self):
+        self.collection = Collection.objects.create(
+            name='Test Collection', description='Test Collection Description'
+        )
+
+        self.tag_set_a = {'apple', 'banana', 'orange'}
+        self.tag_set_b = {'grape', 'kiwi', 'pear'}
+        self.tag_set_c = {'lemon', 'lime', 'mango'}
+
+        self.mixed_tag_set = {'apple', 'grape', 'lemon'}
+
+        self.dirty_tag_set = {'HaT~', 'four* tacos', '123 hoop!!'}
+
+        self.collection.services.tag.add_tags_from_tag_set(self.tag_set_a)
+        self.collection.services.tag.add_tags_from_tag_set(self.tag_set_b)
+        self.collection.services.tag.add_tags_from_tag_set(self.tag_set_c)
+
+        self.collection.services.tag.add_tags_from_tag_set(self.mixed_tag_set)
+
+        self.collection.services.tag.add_tags_from_tag_set(self.dirty_tag_set)
+
+    def test_tag_removal(self):
+        self.assertIn('apple', self.collection.tag_set)
+
+        self.collection.services.tag.remove_tags_by_tag_set(self.mixed_tag_set)
+
+        self.assertNotIn('lemon', self.collection.tag_set)
+
+        self.assertIn('kiwi', self.collection.tag_set)
+
+    def test_tag_add_and_set(self):
+        self.collection.services.tag.set_tags_from_tag_set(self.mixed_tag_set)
+
+        self.assertIn('lemon', self.collection.tag_set)
+
+        self.assertNotIn('banana', self.collection.tag_set)
+
+    def test_tag_count(self):
+        self.assertEqual(Tag.objects.count(), 12)
+        self.assertEqual(self.collection.tags.count(), 12)
+
+    def test_tag_removal(self):
+        self.collection.services.tag.remove_tags_by_tag_set(self.tag_set_a)
+
+        self.assertEqual(self.collection.tags.count(), 9)
+
+    def test_tag_bool_methods(self):
+        self.collection.services.tag.remove_tags_by_tag_set(self.tag_set_b)
+
+        self.assertTrue(self.collection.services.tag.has_tags_in_tag_set(self.tag_set_c))
+        self.assertFalse(self.collection.services.tag.has_tags_in_tag_set(self.mixed_tag_set))
+
+    def test_tag_matching_methods(self):
+        self.assertEqual(len(self.collection.services.tag.get_matching_tags_from_tag_set(self.tag_set_a)), 3)
+
+        self.collection.services.tag.remove_tags_by_tag_set(self.tag_set_a)
+
+        self.assertEqual(len(self.collection.services.tag.get_matching_tags_from_tag_set(self.tag_set_a)), 0)
+        self.assertEqual(len(self.collection.services.tag.get_matching_tags_from_tag_set(self.tag_set_b)), 3)
+        self.assertEqual(len(self.collection.services.tag.get_matching_tags_from_tag_set(self.mixed_tag_set)), 2)
+
+        self.collection.services.tag.remove_tags_by_tag_set(self.tag_set_b)
+
+        self.assertEqual(len(self.collection.services.tag.get_matching_tags_from_tag_set(self.tag_set_b)), 0)
+
+        self.assertEqual(len(self.collection.services.tag.get_matching_tags_from_tag_set(self.mixed_tag_set)), 1)
+
+    def test_tag_metric_methods(self):
+        self.assertAlmostEqual(
+            self.collection.services.tag.get_matching_percentage_of_tag_set(self.tag_set_a),
+            1.00,
+            2
+        )
+
+        self.assertAlmostEqual(
+            self.collection.services.tag.get_matching_percentage_of_model_tags_from_tag_set(self.tag_set_b),
+            0.25,
+            2
+        )
+
+        self.collection.services.tag.remove_tags_by_tag_set(self.mixed_tag_set)
+
+        self.assertAlmostEqual(
+            self.collection.services.tag.get_matching_percentage_of_tag_set(self.tag_set_a),
+            0.666,
+            2
+        )
+
+
+        self.assertAlmostEqual(
+            self.collection.services.tag.get_matching_percentage_of_model_tags_from_tag_set(self.tag_set_b),
+            0.222,
+            2
+        )
+

django_spire/core/tag/tools.py

@@ -0,0 +1,66 @@
+def get_matching_tag_set_from_tag_sets(tag_set_a: set[str], tag_set_b: set[str]) -> set[str]:
+    return tag_set_a.intersection(tag_set_b)
+
+
+def get_matching_count_from_tag_sets(tag_set_a: set[str], tag_set_b: set[str]) -> int:
+    return len(get_matching_tag_set_from_tag_sets(tag_set_a, tag_set_b))
+
+
+def get_matching_a_percentage_from_tag_sets(tag_set_a: set[str], tag_set_b: set[str]) -> float:
+    try:
+        return get_matching_count_from_tag_sets(tag_set_a, tag_set_b) / len(tag_set_a)
+    except ZeroDivisionError:
+        return 0.0
+
+
+def get_matching_b_percentage_from_tag_sets(tag_set_a: set[str], tag_set_b: set[str]) -> float:
+    try:
+        return get_matching_count_from_tag_sets(tag_set_a, tag_set_b) / len(tag_set_b)
+    except ZeroDivisionError:
+        return 0.0
+
+
+def get_score_percentage_from_tag_set_weighted(tag_set_actual: set[str], tag_set_reference: set[str]) -> float:
+    total_points = len(simplify_tag_set(tag_set_reference))
+
+    multiplier = get_matching_count_from_tag_sets(tag_set_actual, tag_set_reference)
+
+    weighted_points = sum(
+        weight
+        for tag, weight in simplify_and_weight_tag_set_to_dict(tag_set_reference).items()
+        if tag in tag_set_actual
+    )
+
+    if weighted_points == 0 or total_points == 0:
+        return 0.0
+
+    return (weighted_points / total_points) * multiplier
+
+
+def simplify_tag_set(tag_set: set[str]) -> set[str]:
+    return set(simplify_tag_set_to_list(tag_set))
+
+
+def simplify_tag_set_to_list(tag_set: set[str]) -> list[str]:
+    simplified_tag_words = []
+
+    for tag in tag_set:
+        tag_words = tag.split('-')
+        simplified_tag_words.extend(tag_words)
+
+    return simplified_tag_words
+
+
+def simplify_and_weight_tag_set_to_dict(tag_set: set[str]) -> dict[str, int]:
+    simplified_and_weighted_tag_words = {}
+
+    for tag_word in simplify_tag_set_to_list(tag_set):
+        simplified_and_weighted_tag_words[tag_word] = simplified_and_weighted_tag_words.get(tag_word, 0) + 1
+
+    return dict(
+        sorted(
+            simplified_and_weighted_tag_words.items(),
+            key=lambda item: item[1],
+            reverse=True
+        )
+    )

django_spire/core/templates/django_spire/tag/element/tag.html

@@ -0,0 +1 @@
+<span class="badge rounded-pill fw-normal border border-app-primary text-app-primary">{{ tag|title }} {{ weight|default:1 }}</span>

django_spire/core/templatetags/spire_core_tags.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import random
 import string
+from typing import Any
 
 from typing_extensions import Sequence, TYPE_CHECKING, TypeVar
 
@@ -48,6 +49,17 @@ def content_type_url(url_name: str, obj: T, **kwargs) -> str:
     return reverse(url_name, kwargs=kwargs)
 
 
+@register.filter
+def safe_dict_items(dictionary: dict) -> Any:
+    """
+    Explicitly call .items() on a dictionary, bypassing key lookup.
+    Use when the dict has a key named 'items' and you need the method.
+    """
+    if hasattr(dictionary, 'items'):
+        return dictionary.items()
+    return []
+
+
 @register.filter
 def in_list(value: str, arg: str) -> bool:
     """

django_spire/knowledge/collection/models.py

@@ -5,7 +5,7 @@ from django.db import models
 from django_spire.auth.group.models import AuthGroup
 from django_spire.contrib import Breadcrumbs
 from django_spire.contrib.ordering.mixins import OrderingModelMixin
-from django_spire.core.tags.mixins import TagsModelMixin
+from django_spire.core.tag.mixins import TagModelMixin
 from django_spire.contrib.utils import truncate_string
 from django_spire.history.mixins import HistoryModelMixin
 from django_spire.knowledge.collection.querysets import CollectionQuerySet
@@ -16,7 +16,7 @@ from django_spire.knowledge.collection.services.service import CollectionGroupSe
 class Collection(
     HistoryModelMixin,
     OrderingModelMixin,
-    TagsModelMixin,
+    TagModelMixin,
 ):
     parent = models.ForeignKey(
         'self',

django_spire/knowledge/collection/services/tag_service.py

@@ -4,14 +4,16 @@ from typing import TYPE_CHECKING
 
 from dandy import Prompt
 
-from django_spire.contrib.service import BaseDjangoModelService
-from django_spire.core.tags.intelligence.tag_set_bot import TagSetBot
+from django_spire.core.tag.intelligence.tag_set_bot import TagSetBot
+from django_spire.core.tag.service.tag_service import BaseTagService
+from django_spire.core.tag.tools import simplify_tag_set, simplify_and_weight_tag_set_to_dict, \
+    get_score_percentage_from_tag_set_weighted
 
 if TYPE_CHECKING:
     from django_spire.knowledge.collection.models import Collection
 
 
-class CollectionTagService(BaseDjangoModelService['Collection']):
+class CollectionTagService(BaseTagService['Collection']):
     obj: Collection
 
     def process_and_set_tags(self):
@@ -24,11 +26,11 @@ class CollectionTagService(BaseDjangoModelService['Collection']):
             content=collection_prompt
         )
 
-        self.obj.set_tags_from_tag_set(
+        self.set_tags_from_tag_set(
             tag_set=tag_set,
         )
 
-    def get_aggregated_tag_set(self):
+    def get_aggregated_tag_set(self) -> set[str]:
         tag_set = self.obj.tag_set
 
         for collection in self.obj.children.active():
@@ -39,14 +41,14 @@ class CollectionTagService(BaseDjangoModelService['Collection']):
 
         return tag_set
 
-    def get_aggregated_tag_set_simplified(self):
-        tag_set = self.obj.tag_set_simplified
-
-        for collection in self.obj.children.active():
-            tag_set.update(collection.services.tag.get_aggregated_tag_set())
-
-        for entry in self.obj.entries.active():
-            tag_set.update(entry.tag_set_simplified)
+    def get_score_percentage_from_aggregated_tag_set_weighted(self, tag_set: set[str]) -> float:
+        return get_score_percentage_from_tag_set_weighted(
+            tag_set_actual=tag_set,
+            tag_set_reference=self.get_aggregated_tag_set()
+        )
 
-        return tag_set
+    def get_simplified_aggregated_tag_set(self) -> set[str]:
+        return simplify_tag_set(self.get_aggregated_tag_set())
 
+    def get_simplified_and_weighted_aggregated_tag_set(self) -> dict[str, int]:
+        return simplify_and_weight_tag_set_to_dict(self.get_aggregated_tag_set())

django_spire/knowledge/entry/models.py

@@ -3,7 +3,7 @@ from django.urls import reverse
 
 from django_spire.contrib import Breadcrumbs
 from django_spire.contrib.ordering.mixins import OrderingModelMixin
-from django_spire.core.tags.mixins import TagsModelMixin
+from django_spire.core.tag.mixins import TagModelMixin
 from django_spire.contrib.utils import truncate_string
 from django_spire.history.mixins import HistoryModelMixin
 from django_spire.knowledge.collection.models import Collection
@@ -15,7 +15,7 @@ from django_spire.knowledge.entry.version.models import EntryVersion
 class Entry(
     HistoryModelMixin,
     OrderingModelMixin,
-    TagsModelMixin
+    TagModelMixin
 ):
     collection = models.ForeignKey(
         Collection,

django_spire/knowledge/entry/querysets.py

@@ -30,3 +30,8 @@ class EntryQuerySet(HistoryQuerySet, OrderingQuerySetMixin):
                 current_version__status=EntryVersionStatusChoices.DRAFT
             )
         )
+
+    def get_by_version_block_id(self, version_block_id: int) -> Entry:
+        return self.get(
+            current_version__block__id=version_block_id
+        )

django_spire/knowledge/entry/services/tag_service.py

@@ -4,21 +4,21 @@ from typing import TYPE_CHECKING
 
 from dandy import Prompt
 
-from django_spire.contrib.service import BaseDjangoModelService
-from django_spire.core.tags.intelligence.tag_set_bot import TagSetBot
+from django_spire.core.tag.intelligence.tag_set_bot import TagSetBot
+from django_spire.core.tag.service.tag_service import BaseTagService
 
 if TYPE_CHECKING:
     from django_spire.knowledge.entry.models import Entry
 
 
 
-class EntryTagService(BaseDjangoModelService['Entry']):
+class EntryTagService(BaseTagService['Entry']):
     obj: Entry
 
     def process_and_set_tags(self):
         entry_prompt = Prompt()
 
-        entry_prompt.text(self.obj.name)
+        entry_prompt.sub_heading(self.obj.name)
 
         for version_block in self.obj.current_version.blocks.all():
             entry_prompt.text(f'{version_block.render_to_text()}')
@@ -27,7 +27,7 @@ class EntryTagService(BaseDjangoModelService['Entry']):
             content=entry_prompt
         )
 
-        self.obj.set_tags_from_tag_set(
+        self.set_tags_from_tag_set(
             tag_set=tag_set,
         )
 

django_spire/knowledge/intelligence/bots/entries_search_llm_bot.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from dandy import Bot, Prompt
+
+from django_spire.knowledge.intelligence.intel.entry_intel import EntriesIntel
+
+if TYPE_CHECKING:
+    from django_spire.knowledge.entry.models import Entry
+
+
+class EntriesSearchBot(Bot):
+    llm_role = 'Knowledge Entry Search Assistant'
+    llm_task = 'Read through the knowledge and return information and the block id that relevant to the information request.'
+    llm_guidelines = (
+        Prompt()
+        .list([
+            'Please read through all the blocks and return 2 of the most relevant ones.',
+            'You can add any of the text in the knowledge entries to the 2 responses if it helps.',
+            'Make sure the relevant heading text is from a heading with mark down formatting.',
+            'When returning the relevant heading remove any of the markdown formating characters.',
+        ])
+    )
+    llm_intel_class = EntriesIntel
+
+    def process(self, user_input: str, entries: list[Entry]) -> EntriesIntel:
+
+        entry_prompt = Prompt()
+        entry_prompt.sub_heading('Information Request')
+        entry_prompt.line_break()
+        entry_prompt.text(f'{user_input}')
+        entry_prompt.line_break()
+        entry_prompt.sub_heading('Knowledge Entries')
+        entry_prompt.line_break()
+
+        for entry in entries:
+            for version_block in entry.current_version.blocks.all():
+                if version_block.render_to_text() != '\n':
+                    entry_prompt.text(f'{version_block.id}: {version_block.render_to_text()}')
+
+        return self.llm.prompt_to_intel(
+            prompt=entry_prompt,
+        )
+

django_spire/knowledge/intelligence/intel/entry_intel.py

@@ -1,16 +1,36 @@
 from __future__ import annotations
 
+from enum import Enum
+
 from dandy import BaseIntel, BaseListIntel
 
-from django_spire.knowledge.intelligence.intel.collection_intel import CollectionIntel
+from django_spire.knowledge.entry.models import Entry
+
+
+class EntryRelevancy(str, Enum):
+    EXTREMELY = 'Extremely'
+    VERY = 'Very'
+    SOMEWHAT = 'Somewhat'
+    NOT_SO_MUCH = 'Not so much'
+    NO_RELEVANCE = 'No Relevance'
 
 
 class EntryIntel(BaseIntel):
     relevant_heading_text: str
-    relevant_subject_text: str
+    relevant_text: str
     relevant_block_id: int
-    entry_id: int = None
-    collection_intel: CollectionIntel = None
+    relevancy: EntryRelevancy
+
+    def __str__(self):
+        return self.relevant_heading_text + ' ' + self.relevant_text
+
+    @property
+    def collection(self):
+        return self.entry.collection
+
+    @property
+    def entry(self):
+        return Entry.objects.get_by_version_block_id(self.relevant_block_id)
 
 
 class EntriesIntel(BaseListIntel[EntryIntel]):

django_spire/knowledge/intelligence/workflows/knowledge_workflow.py

@@ -5,51 +5,72 @@ from typing import TYPE_CHECKING
 from django.core.handlers.wsgi import WSGIRequest
 
 from django_spire.ai.chat.message_intel import DefaultMessageIntel, BaseMessageIntel
-from django_spire.knowledge.intelligence.bots.entry_search_llm_bot import EntrySearchBot
-from django_spire.knowledge.intelligence.intel.entry_intel import EntriesIntel
+from django_spire.core.tag.intelligence.tag_set_bot import TagSetBot
+from django_spire.knowledge.collection.models import Collection
+from django_spire.knowledge.intelligence.bots.entries_search_llm_bot import EntriesSearchBot
 from django_spire.knowledge.intelligence.intel.message_intel import KnowledgeMessageIntel
-from django_spire.knowledge.intelligence.decoders.collection_decoder import get_collection_decoder
-from django_spire.knowledge.intelligence.decoders.entry_decoder import get_entry_decoder
 
 if TYPE_CHECKING:
     from django.core.handlers.wsgi import WSGIRequest
     from dandy.llm.request.message import MessageHistory
 
-
 NO_KNOWLEDGE_MESSAGE_INTEL = DefaultMessageIntel(
     text='Sorry, I could not find any information on that.'
 )
 
 
 def knowledge_search_workflow(
-    request: WSGIRequest,
-    user_input: str,
-    message_history: MessageHistory | None = None,
+        request: WSGIRequest,
+        user_input: str,
+        message_history: MessageHistory | None = None,
 ) -> BaseMessageIntel | None:
-    collection_decoder = get_collection_decoder()
-    collections = collection_decoder.process(user_input).values
+    user_tag_set = TagSetBot().process(user_input)
 
-    if collections[0] is None:
-        return NO_KNOWLEDGE_MESSAGE_INTEL
+    def get_top_scored_from_dict_to_list(
+            scored_dict: dict[str, float],
+            score_floor: float = 0.05
+    ) -> list:
+        if not scored_dict:
+            return []
 
-    entries = []
+        min_score = min(scored_dict.values())
+        max_score = max(scored_dict.values())
 
-    for collection in collections:
-        if collection.entry_count > 0:
-            entry_decoder = get_entry_decoder(collection=collection)
+        if min_score == 0 and max_score == 0:
+            return []
 
-            entries.extend(entry_decoder.process(user_input).values)
+        median_score = (max_score - min_score) / 2
 
-    entries = [entry for entry in entries if entry is not None]
+        top_scored_list = []
 
-    if not entries:
-        return NO_KNOWLEDGE_MESSAGE_INTEL
+        for key, value in scored_dict.items():
+            if value >= score_floor and value >= median_score:
+                top_scored_list.append(key)
 
-    entries_intel = EntriesIntel(entry_intel_list=[])
+        return top_scored_list
 
-    for entry in entries:
-        entries_intel.append(
-            EntrySearchBot().process(user_input=user_input, entry=entry)
+    collections = get_top_scored_from_dict_to_list({
+        collection: collection.services.tag.get_score_percentage_from_aggregated_tag_set_weighted(
+            user_tag_set
         )
+        for collection in Collection.objects.all().annotate_entry_count()
+    })
+
+    entries = get_top_scored_from_dict_to_list({
+        entry: entry.services.tag.get_score_percentage_from_tag_set_weighted(user_tag_set)
+        for collection in collections
+        for entry in collection.entries.all()
+    })
+
+    if not entries:
+        return NO_KNOWLEDGE_MESSAGE_INTEL
+
+    entries_intel = EntriesSearchBot(llm_temperature=0.0).process(
+        user_input=user_input,
+        entries=entries
+    )
 
-    return KnowledgeMessageIntel(body=f'Entries: {entries_intel}', entries_intel=entries_intel)
+    return KnowledgeMessageIntel(
+        body=f'{" ".join([str(entry) for entry in entries_intel])}',
+        entries_intel=entries_intel,
+    )