Améliorer la recherche hybride avec des graphiques de connaissances progressifs

jeDans l’industrie manufacturière, les soins de santé et même le service client, la seule réponse suffisamment bonne est une réponse précise. Un LLM peut vous donner une réponse fantastique, mais est-ce la bonne ? Les données sont-elles correctes ? Les données sont-elles actuelles ? La confiance dans l’IA repose sur la confiance dans les données, et c’est pourquoi le travail acharné ne consiste pas seulement à former le modèle d’IA, mais à développer les connaissances qui le sous-tendent.

La plupart des systèmes GenAI ne conservent pas les commentaires et ne s’ajustent pas au fil du temps. Plutôt que de s’entraîner sur davantage de données, l’IA a besoin d’une validation humaine continue et d’une contribution contextuelle pour s’améliorer. Ces commentaires peuvent être capturés dans un modèle de connaissances, permettant une récupération et une corrélation efficaces via des Knowledge Graphs.

Chez Progress, notre technologie Progressive Graphs© en instance de brevet utilise une architecture sémantique RAG pour enrichir les modèles de connaissances avec des entrées validées, permettant ainsi une recherche sémantique fiable en temps réel. À mesure que le graphique évolue, il améliore la pertinence et la précision, permettant aux implémentations internes d’IA d’évoluer et de surpasser les réponses LLM de base. Ce blog est destiné à vous lancer dans votre voyage avec le Sémaphore de progression outils de développement en main.

Graphiques progressifs : qu’est-ce qu’ils sont et comment ils fonctionnent

Dans notre précédent série de blogs sémantiques RAGnous avons discuté de l’exploitation des graphiques de connaissances pour améliorer vos flux de travail de recherche hybride. Les graphiques de connaissances contiennent des faits et une terminologie spécifique au domaine qui prennent en charge la récupération d’informations et mettent vos données en contexte. Bien qu’il existe de nombreux modèles de connaissances bien établis, notamment des ontologies et des taxonomies conformes aux normes de l’industrie, ils peuvent ne pas correspondre à la manière dont vos utilisateurs interagissent avec le système.

Nous présenterons un flux de travail Progressive Graph dans lequel nous pouvons améliorer et augmenter ces modèles hautement organisés.

Les graphiques progressifs sont un processus d’amélioration progressive de votre graphique de connaissances en fonction des interactions de vos utilisateurs ou de votre IA agentique avec vos données propriétaires. Il interprète les entrées de l’utilisateur pour les mots-clés, les termes de recherche et bien plus encore. Nos experts en la matière (PME) seront au courant pour organiser et sauvegarder le modèle de production.

Voici les étapes du flux du graphique progressif :

1. L’utilisateur / Agentic AI saisit sa question ou sa demande de tâche

2. Le LLM analyse et extrait des concepts ou synonymes potentiels clés

3. Déterminez si le concept est nouveau et si oui :

4. Créez un nouveau concept et envoyez-le à l’éditeur d’ontologie de Semaphore

5. Montrez aux experts en la matière examinant la nouvelle suggestion de concept dans le flux de travail de l’outil de révision des connaissances du sémaphore.

6. Demander au taxonomiste/ontologue/architecte de l’information d’examiner et d’approuver les ajouts de modèles PME dans Knowledge Model Manager pour garantir la gouvernance des données.

Configuration de votre modèle de connaissances

Dans le gestionnaire de modèles de connaissances Semaphore, nous allons créer une tâche. Les tâches sont utilisées dans le cadre du flux de travail et de la gouvernance des données. Ils sont utilisés pour contrôler ce qui est modifié dans le modèle et garantir que le modèle de production n’est pas modifié sans approbation. Vous pouvez considérer cette tâche comme un bac à sable pour les modifications. Le gestionnaire de modèles peut accepter, rejeter et ajuster les concepts tout au long du processus.

Une fois la tâche créée, nous pouvons cliquer dessus et commencer à regarder notre modèle. Semaphore a également la capacité de externaliser les modifications du modèle. L’outil d’examen des connaissances (KRT) nous permettra d’apporter des modifications aux concepts et d’introduire de nouveaux concepts que nos PME pourront examiner.

Nous commençons par cliquer sur Créer une tâche à partir des paramètres du modèle et suivre l’assistant.

Maintenant que nous disposons d’un workflow KRT, nous pouvons y accéder par programmation. Nous présenterons l’écriture de cette tâche via le SDK Java. Vous pouvez tirer parti de ce flux de travail Progressive Graph dans le Niveau intermédiaire LangChain4j que nous avons mis en place dans notre précédent article de blog.

Connecter le niveau intermédiaire

Analyser la question de l’utilisateur

Nous allons d’abord prendre en compte la question de l’utilisateur et l’analyser à l’aide d’un grand modèle linguistique (LLM). Nous pouvons exploiter les assistants de LangChain4j pour créer une invite et soumettre la demande au LLM.

public interface TermExtractAssistant { 

      @SystemMessage( 

            "Extract search keywords from the users question. " + 
            "  The response should be in RFC compliance JSON format with property searchTerms" + 
            "  values as array of terms." + 
            "  Example: { 'searchTerms': [] }" + 
            "  Do not include markdown code blocks in your response. " + 
            "  Respond only with valid JSON. Do not write an introduction or summary." + 
            "  QUERY: {query}" 
           ) 
    Result<String> chat(String question); 
} 

Cette invite est utilisée pour extraire les termes de recherche de la question d’origine de l’utilisateur et générer une représentation JSON des termes. Nous utiliserons ce JSON pour parcourir chaque terme afin de générer de nouveaux concepts. Une petite classe Java sera créée pour marshaler le JSON.

@Getter @Setter 
public class AISearchTerms { 
    private List<String> searchTerms; 
} 

Désormais, en utilisant LangChain4j AiServices et ChatModels, nous pouvons soumettre la question au LLM et en extraire les termes.

public AISearchTerms getQuestionConceptsByAI(String query) { 
  AISearchTerms searchTerms = null; 
  try { 
    TermExtractAssistant termExtractAssistant = AiServices.builder(TermExtractAssistant.class) 
        .chatLanguageModel(chatLanguageModel) 
        .build(); 
 
    Result<String> result = termExtractAssistant.chat(query); 
    String resultText = result.content(); 
    LOGGER.info("Query term extract: " + resultText); 
    searchTerms = this.objectMapper.readValue(resultText, AISearchTerms.class); 
    return searchTerms; 
  } catch (JsonProcessingException e) { 
    LOGGER.error("Unable to parse search terms from LLM. ", e); 
  } 
  return searchTerms; 
} 

Nous pouvons maintenant passer à l’utilisation de ces nouveaux concepts et à leur écriture dans la tâche de l’outil de révision des connaissances sur le sémaphore.

Soumission de l’outil d’examen des connaissances sur les sémaphores

Semaphore est livré avec un client Java pour interagir avec le Knowledge Model Manager. Ce client dispose d’un éditeur d’ontologie qui peut être exploité pour communiquer de manière pragmatique avec le modèle de connaissances. Nous allons d’abord créer une connexion en utilisant un petit bout de code.

 public OEClientReadWrite getProgressiveGraphClient() throws CloudException { 
        OEClientReadWrite oeClient = new OEClientReadWrite(); 
        oeClient.setKRTClient(true); 
        oeClient.setBaseURL(this.semaphoreConfig.getOeURL()); 
        oeClient.setModelUri(this.semaphoreConfig.getModelTaskUri()); 
  
        if (this.semaphoreConfig.getTokenRequestURL() != null && this.semaphoreConfig.getKey() != null) { 
            TokenFetcher tokenFetcher = new TokenFetcher(this.semaphoreConfig.getTokenRequestURL(), this.semaphoreConfig.getKey()); 
            Token token = tokenFetcher.getAccessToken(); 
            oeClient.setCloudToken(token); 
        } else { 
            oeClient.setHeaderToken(this.semaphoreConfig.getLocalToken()); 
        } 
 
        return oeClient; 
    } 

Le code ci-dessus crée un nouveau client avec des connexions à l’instance Semaphore et à la tâche de modèle spécifique avec laquelle vous essayez d’interagir. Si vous utilisez Sémaphore dans le Cloudvous devrez utiliser TokenFetcher pour créer le client. Sinon, créez un jeton d’accès local via l’écran d’administration du Sémaphore. Avec cela, vous pouvez désormais interagir avec cette tâche de l’outil de révision des connaissances.

public void writeAiTermsToTask(AISearchTerms aiSearchTerms) throws CloudException { 
  OEClientReadWrite oeClient = this.connectionUtils.getProgressiveGraphClient(); 
 
  try { 
    String modelUri = oeClient.getModelUri(); 
    ConceptScheme conceptScheme = oeClient.getConceptSchemeByName(this.semaphoreConfig.getConceptScheme(), EN); 
    for (String conceptName : aiSearchTerms.getSearchTerms()) { 
      try { 
 
       // Create the concept with a preferred label. 
       List<Label> labels = Collections.singletonList(new Label(EN, conceptName)); 
       String encodedConceptName = URLEncoder.encode( 
           conceptName.toLowerCase().replaceAll(" ", "-"), 
           StandardCharsets.UTF_8.toString()); 
       Concept concept = new Concept(oeClient, modelUri + HASH + encodedConceptName, labels); 
 
       // Populate metadata with prompt question. 
       MetadataValue metadataValue = new MetadataValue(EN, query); 
       Map<String, Collection<MetadataValue>> metadata = Map.of("skos:note", Set.of(metadataValue)); 
 
       // Write concept to KRT Task 
       oeClient.createConcept(conceptScheme.getUri(), concept, metadata); 
 
      } catch (OEClientException e) { 
        LOGGER.error(FAILED_TO_ADD_CONCEPT, e); 
      } catch (UnsupportedEncodingException e) { 
        LOGGER.error(UNABLE_TO_ENCODE_CONCEPT_NAME, e); 
      } 
    } 
  } catch (OEClientException e) { 
    LOGGER.error(ERROR_WITH_OE_CLIENT, e); 
  } 
} 

Nous prenons maintenant cette liste de termes de recherche et générons des concepts. À l’aide du client, nous récupérons l’URI du modèle et le schéma de concepts dans lesquels nous souhaitons insérer les nouveaux concepts. Nous générerons une étiquette et un IRI codé pour le nouveau concept. De plus, nous capturerons les entrées originales de l’utilisateur pour fournir à la PME un contexte supplémentaire. Une fois ces informations créées, nous pouvons maintenant soumettre le nouveau concept, et il sera présent dans la tâche Outil d’examen des connaissances.

Nous soumettrons une question via le point de terminaison de discussion précédent.

Comme nous le voyons dans la tâche KRT, de nouveaux concepts ont été ajoutés. La PME peut désormais décider d’accepter, de refuser ou de fusionner des concepts. Cela permet un flux de travail Human-in-the-Loop.

Conclusion

Progressive Graphs présente une méthode dynamique et pilotée par l’utilisateur pour faire évoluer les graphiques de connaissances. En capturant les interactions des utilisateurs en temps réel et en exploitant la puissance des grands modèles linguistiques (LLM) pour extraire des concepts significatifs, les organisations peuvent continuellement affiner et étendre leurs modèles sémantiques. Cette approche comble efficacement le fossé entre les ontologies statiques et le comportement réel des utilisateurs, tout en maintenant la qualité et la pertinence grâce à la supervision d’experts en la matière (SME).

De plus, ce flux de travail prend en charge les processus humains essentiels, permettant aux experts du domaine et aux équipes de gouvernance d’examiner et de valider les sorties automatisées. Même si l’automatisation accélère l’enrichissement, elle peut introduire des problèmes tels qu’une terminologie incorrecte, des concepts obsolètes ou des incohérences structurelles. Les graphiques progressifs atténuent ces risques en combinant l’intelligence automatisée avec une validation dirigée par des experts, garantissant ainsi les plus hauts niveaux de précision dans l’amélioration des modèles de connaissances du domaine.

En conséquence, les capacités de recherche hybrides deviennent plus intuitives, sensibles au contexte et alignées sur les besoins réels des utilisateurs, ce qui génère de meilleurs résultats dans vos systèmes de recherche d’informations.