phenomenal ai
v0.0.4
Phänomenales KI ist ein TypeScript-Paket zum Erstellen eines rundenbasierten Konversations-Eingabeaufforderungsgenerators für Großsprachenmodelle. Dieses Paket enthält die Bausteine für die Simulation von Konversationsinteraktionen zwischen mehreren Entitäten, die als Akteure bezeichnet werden. Akteure können Informationen austauschen, sich am Dialog tätigen und den Konversationsverlauf dynamisch auf vordefinierten Regeln anpassen.
mustache ), wodurch es leicht und einfach zu bedienen ist. Sie können das Paket über npm installieren:
npm install @wecandobetter/phenomenal-aiOder über Garn:
yarn add @wecandobetter/phenomenal-ai Die Conversation verkauft alle Schauspieler und verwaltet die Geschichte, den Kontext und die Planung der Wendungen des Schauspielers. Die Actor repräsentiert einen Schauspieler im Gespräch.
Das folgende Beispiel zeigt, wie man die Conversation verwendet, um ein Gespräch zwischen zwei Schauspielern zu simulieren.
import { Actor , Conversation } from "@wecandobetter/phenomenal-ai" ;
import { generateText } from "./text-generation" ; // provide your own text generation function
// Define your actors
const actors = [
new Actor ( "John" ) ,
new Actor ( "Emma" ) ,
] ;
// Initialize a conversation
const conversation = new Conversation ( "Morning Talk" , { actors } ) ;
// Add a context entry
conversation . context . set ( "topic" , "Current topic of conversation" , "AI Ethics" ) ;
// Make a query:
const response = await conversation . query ( {
speaker : actors [ 0 ] , // the speaker, i.e. the actor asking the question
answerer : actors [ 1 ] , // the answerer, i.e. the actor answering the question
query : "What is the topic of conversation?" , // the query to be answered
generateText , // provide your own text generation function
store : true , // store the response in the history
} ) ;
console . log ( ` ${ response . speaker } : ${ response . text } ` ) ;
// Moderate the conversation by injecting a new message:
conversation . inject ( "Let's get back to the topic of conversation." , {
speaker : "Moderator" , // the speaker of the message (defaults to `System`)
ephemeral : true , // this message will not be stored in the history
} ) ;
// Make one turn:
const turn = await conversation . turn ( {
actor : conversation . scheduler . getNextSpeaker ( ) , // get the next speaker from the scheduler
generateText , // provide your own text generation function
} ) ;
console . log ( ` ${ turn . speaker } : ${ turn . text } ` ) ;
// or use an async generator:
const ac = new AbortController ( ) ;
const loop = conversation . loop ( {
signal : ac . signal , // provide an AbortSignal to stop the loop
generateText , // provide your own text generation function
scheduler : conversation . scheduler , // provide your own scheduler
} ) ;
for await ( const turn of loop ) {
console . log ( ` ${ turn . speaker } : ${ turn . text } ` ) ;
} Die Hauptklassen dieses Pakets sind Conversation , ConversationHistory und Actor .
Die Conversation stellt ein kontinuierliches Gespräch zwischen mehreren Schauspielern dar.
id : Eindeutige Kennung für das Gespräch.name : Name des Gesprächs.actors : Eine Reihe von Actor , die an dem Gespräch teilnehmen.history : Die Geschichte des Gesprächs.context : gemeinsamer Kontext zwischen allen Akteuren im Gespräch. Dies sind die Methoden, die in der Conversation verfügbar sind.
new Conversation(name: string, { actors: Actor[], generateText?: GenerateText, scheduler?: Scheduler, messages?: Message[], windowss?: { history?: number } }) Initialisiert eine neue Instanz der Conversation .
const conversation = new Conversation ( "Morning Talk" , {
actors : [
new Actor ( "John" ) ,
new Actor ( "Emma" ) ,
] ,
generateText : generateText , // provide your own text generation function
scheduler : RoundRobinScheduler , // provide your own scheduler
messages : [ ] , // bootstrap the conversation with messages
windows : { // configure the conversation window
max : 1024 , // the maximum number of tokens to unmask in the history
} ,
} ) ; conversation.inject(text: string, { speaker = "System" embeddings?: number[][], ephemeral?: true })Injiziert eine neue Nachricht in das Gespräch. Gibt die injizierte Nachricht zurück.
const message = conversation . inject (
"Let's get back to the topic of conversation." ,
{
speaker : "Moderator" ,
ephemeral : true , // if true, the message will not be stored in the history after the next turn
} ,
) ; conversation.query({ speaker: Actor, answerer: Actor, query: string, generateText?: GenerateText, store = false })Gibt ein Versprechen zurück, das sich auf eine Drehreaktion beschließt.
const response = await conversation . query ( {
speaker : actors [ 0 ] , // the speaker, i.e. the actor asking the question
answerer : actors [ 1 ] , // the answerer, i.e. the actor answering the question
query : "What is the topic of conversation?" , // the query to be answered
generateText , // provide your own text generation function
store : true , // store the response in the history
} ) ;
console . log ( ` ${ response . speaker } : ${ response . text } ` ) ; conversation.turn({ actor: Actor, generateText?: GenerateText })Gibt ein Versprechen zurück, das sich auf eine Drehreaktion beschließt.
const response = await conversation . turn ( {
actor : conversation . scheduler . getNextSpeaker ( ) , // get the next speaker from the scheduler
generateText , // provide your own text generation function
} ) ;
console . log ( ` ${ response . speaker } : ${ response . text } ` ) ; conversation.loop({ signal: AbortSignal; generateText?: GenerateText })Ein asynchrischer Generator, der den Sprecher, den Text und optional die Einbettungen jeder Runde in der Konversation ergibt.
const ac = new AbortController ( ) ;
// start the loop, which will yield the responses
const loop = conversation . loop ( {
signal : ac . signal , // provide an AbortSignal to stop the loop
generateText , // provide your own text generation function
} ) ;
for await ( const response of loop ) {
console . log ( ` ${ response . speaker } : ${ response . text } ` ) ;
} conversation.toJSON()Gibt eine JSON -Darstellung des Gesprächs zurück.
const json = conversation . toJSON ( ) ; Die ConversationHistory -Klasse repräsentiert die Geschichte eines Gesprächs.
messages : Array von Nachrichten in der Konversation. Dies sind die Methoden, die in der ConversationHistory -Klasse verfügbar sind.
new ConversationHistory(messages?: Message[]) Initialisiert eine neue Instanz der ConversationHistory -Klasse.
const history = new ConversationHistory ( [
{ speaker : "John" , text : "Hello, Emma!" } ,
{ speaker : "Emma" , text : "Hi, John!" } ,
] ) ; history.push(message: PartialBy<Message, "feedback">)Schiebt eine neue Nachricht in die Geschichte.
history . push ( { actor : "John" , text : "Hello, Emma!" } ) ; history.getMessagesFor(actor: string)Gibt eine Karte mit Indizes und Nachrichten für den angegebenen Schauspieler zurück.
const messages = history . getMessagesFor ( "John" ) ; history.getStats()Gibt Statistiken über die Geschichte zurück. Die Statistiken werden vom Schauspieler gruppiert.
const stats = history . getStats ( ) ;
console . log ( stats ) ;
// {
// "Bob": {
// count: 2, // total number of messages
// textCount: 22, // total number of characters
// percentage: 0.5, // percentage of messages in the conversation
// textPercentage: 0.5, // percentage of characters in the conversation
// },
// } history.cleanEphemeral()Entfernt kurzlebige Botschaften aus der Geschichte.
history . cleanEphemeral ( ) ; history.up(message: Message)Fügen Sie der angegebenen Nachricht positives Feedback hinzu.
const message = history . messages [ 0 ] ; // get message from somewhere
history . up ( message ) ; history.down(message: Message)Fügen Sie der angegebenen Nachricht negatives Feedback hinzu.
const message = history . messages [ 0 ] ; // get message from somewhere
history . down ( message ) ; history.first(): MessageGibt die erste Nachricht im Verlauf zurück.
history.last(): MessageGibt die letzte Nachricht im Verlauf zurück.
history.toJSON()Gibt eine JSON -Darstellung der Geschichte zurück.
history.clear()Löscht die Geschichte.
Die Actor repräsentiert eine Einheit, die an einem Gespräch teilnimmt.
id : Eindeutige Kennung für den Schauspieler.name : Name des Schauspielers.template : Vorlage für die Eingabeaufforderungen des Schauspielers.context : gemeinsamer Kontext zwischen allen Akteuren im Gespräch.persona : Persona des Schauspielers.knowledge : Wissen des Schauspielers.memory : Erinnerung an den Schauspieler. Dies sind die in der Actor verfügbaren Methoden.
new Actor(name: string, { template?: string, persona?: Persona, knowledge?: Knowledge, memory?: Memory }) Initialisiert eine neue Instanz der Actor . Wenn keine Vorlage bereitgestellt wird, wird die Standardvorlage verwendet.
const actor = new Actor ( "John" , {
template : "Hello, my name is {{name}}." ,
) ; actor.render(conversation: Conversation)Rendert die Vorlage des Schauspielers in eine Eingabeaufforderung. Die Eingabeaufforderung ist eine Nachricht, die von Ihrem ausgewählten Großsprachmodell verwendet werden kann, um eine Antwort zu generieren.
const prompt = actor . render ( conversation ) ; actor.toJSON()Gibt eine JSON -Darstellung des Schauspielers zurück.
Pull -Anfragen sind willkommen. Für wichtige Änderungen öffnen Sie zuerst ein Problem, um zu besprechen, was Sie ändern möchten. Überprüfen Sie die Seite mit der Ausgabe.
Dieses Projekt ist unter der MIT -Lizenz lizenziert. Nutzen Sie es für Ihre eigenen Projekte.
Happy Coding! ?
Wenn Sie auf Probleme stoßen oder Vorschläge für Verbesserungen haben, können Sie ein Problem oder eine Pull -Anfrage öffnen.
Geben Sie ein ️, wenn Ihnen dieses Projekt gefällt!
Codiert mit ❤️ von wir können es besser machen.
