phenomenal ai

? Fenomenal ai

Phenomenal AI es un paquete TypeScript para construir un generador de aviso conversacional basado en turnos para modelos de idiomas grandes. Este paquete proporciona los bloques de construcción para simular interacciones conversacionales entre múltiples entidades, denominadas actores. Los actores pueden compartir información, participar en el diálogo y ajustar dinámicamente el curso de la conversación basado en reglas predefinidas.

? Características

• Abstracción de alto nivel : la IA fenomenal proporciona un alto nivel de abstracción para los modelos de conversación basados ​​en IA. Esto le permite concentrarse en la lógica de conversación y no en el modelo subyacente.
• ? Múltiples actores : este paquete admite la interacción entre múltiples actores, lo que permite escenarios de conversación complejos. Cada actor puede tener su propia personalidad y preferencias.
• Historia de la conversación : cada conversación tiene una historia que rastrea el curso del diálogo con el tiempo. La historia se utiliza para generar respuestas a nuevas líneas de diálogo.
• ? Contexto compartido : los actores en una conversación comparten un contexto que les permite almacenar y recuperar información relevante para la discusión en curso. El contexto se puede utilizar para almacenar información como el tema de la conversación, la ubicación, la hora del día, etc.
• Programación : el paquete proporciona un mecanismo para decidir el orden de giros entre los actores utilizando programadores. El paquete viene con un programador predeterminado que los programas giran de manera redonda.
• ? Gestión de giros de conversación : controla el flujo de giro de la conversación y proporciona un método para inyectar nuevos mensajes en la conversación. El paquete también proporciona un método para consultar la conversación con una pregunta y obtener una respuesta.
• Gestión de la ventana de contexto : el paquete proporciona un mecanismo para administrar la ventana de contexto. La ventana de contexto es el número de tokens para desenmascarar en la historia al generar una respuesta. Esto le permite controlar el tamaño de solicitud y la cantidad de contexto proporcionado al modelo.
• ? Ligero : el paquete solo tiene una dependencia externa ( mustache ), lo que lo hace liviano y fácil de usar.
• ? Extensible : el paquete está diseñado para ser extensible. Puede proporcionar su propia función de generación de texto, planificador, etc.

? Empezando

Puede instalar el paquete a través de npm :

npm install @wecandobetter/phenomenal-ai

O a través del hilo:

yarn add @wecandobetter/phenomenal-ai

Ejemplos de uso

La clase Conversation encapsula a todos los actores y administra la historia, el contexto y la programación de los giros del actor. La clase Actor representa a un actor en la conversación.

El siguiente ejemplo muestra cómo usar la clase Conversation para simular una conversación entre dos actores.

 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 } ` ) ;
} 

Referencia de API

Las clases principales de este paquete son Conversation , ConversationHistory y Actor .

Conversación

La clase Conversation representa una conversación continua entre múltiples actores.

Propiedades

• id : Identificador único para la conversación.
• name : Nombre de la conversación.
• actors : la variedad de Actor que participan en la conversación.
• history : la historia de la conversación.
• context : contexto compartido entre todos los actores en la conversación.

Métodos

Estos son los métodos disponibles en la clase Conversation .

new Conversation(name: string, { actors: Actor[], generateText?: GenerateText, scheduler?: Scheduler, messages?: Message[], windowss?: { history?: number } })

Inicializa una nueva instancia de la clase 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 })

Inyecta un nuevo mensaje en la conversación. Devuelve el mensaje inyectado.

 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 })

Devuelve una promesa que se resuelve a una respuesta de turno.

 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 })

Devuelve una promesa que se resuelve a una respuesta de turno.

 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 })

Un generador de asíncrono que produce el altavoz, el texto y, opcionalmente, los incrustaciones de cada giro en la conversación.

 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()

Devuelve una representación JSON de la conversación.

 const json = conversation . toJSON ( ) ;

Conversación

La clase ConversationHistory representa la historia de una conversación.

Propiedades

• messages : variedad de mensajes en la conversación.

Métodos

Estos son los métodos disponibles en la clase ConversationHistory .

new ConversationHistory(messages?: Message[])

Inicializa una nueva instancia de la clase ConversationHistory .

 const history = new ConversationHistory ( [
  { speaker : "John" , text : "Hello, Emma!" } ,
  { speaker : "Emma" , text : "Hi, John!" } ,
] ) ; 

history.push(message: PartialBy<Message, "feedback">)

Empuja un nuevo mensaje a la historia.

 history . push ( { actor : "John" , text : "Hello, Emma!" } ) ; 

history.getMessagesFor(actor: string)

Devuelve un mapa de índices y mensajes para el actor dado.

 const messages = history . getMessagesFor ( "John" ) ; 

history.getStats()

Devuelve estadísticas sobre la historia. Las estadísticas están agrupadas por el actor.

 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()

Elimina mensajes efímeros de la historia.

 history . cleanEphemeral ( ) ; 

history.up(message: Message)

Agregue comentarios positivos al mensaje dado.

 const message = history . messages [ 0 ] ; // get message from somewhere
history . up ( message ) ; 

history.down(message: Message)

Agregue comentarios negativos al mensaje dado.

 const message = history . messages [ 0 ] ; // get message from somewhere
history . down ( message ) ; 

history.first(): Message

Devuelve el primer mensaje en la historia.

history.last(): Message

Devuelve el último mensaje en la historia.

history.toJSON()

Devuelve una representación JSON de la historia.

history.clear()

Borra la historia.

Actor

La clase de Actor representa una entidad que participa en una conversación.

Propiedades

• id : Identificador único para el actor.
• name : Nombre del actor.
• template : plantilla para las indicaciones del actor.
• context : contexto compartido entre todos los actores en la conversación.
• persona : Persona del actor.
• knowledge : Conocimiento del actor.
• memory : memoria del actor.

Métodos

Estos son los métodos disponibles en la clase Actor .

new Actor(name: string, { template?: string, persona?: Persona, knowledge?: Knowledge, memory?: Memory })

Inicializa una nueva instancia de la clase de Actor . Si no se proporciona una plantilla, se utilizará la plantilla predeterminada.

 const actor = new Actor ( "John" , {
  template : "Hello, my name is {{name}}." ,
) ; 

actor.render(conversation: Conversation)

Convierte la plantilla del actor en un aviso. El aviso es un mensaje que puede ser utilizado por su modelo de lenguaje grande elegido para generar una respuesta.

 const prompt = actor . render ( conversation ) ; 

actor.toJSON()

Devuelve una representación JSON del actor.

❤️ contribuyendo

Las solicitudes de extracción son bienvenidas. Para cambios importantes, abra primero un problema para discutir lo que le gustaría cambiar. No dude en consultar la página de problemas.

Licencia

Este proyecto tiene licencia bajo la licencia MIT. Siéntase libre de usarlo para sus propios proyectos.

Notas

¡Feliz codificación! ?

Si encuentra algún problema o tiene sugerencias de mejoras, no dude en abrir un problema o una solicitud de extracción.

¡Dale un ️ si te gusta este proyecto!

Codificado con ❤️ por nosotros podemos hacerlo mejor.