@dxos/assistant 0.8.2-main.fbd8ed0 → 0.8.2-staging.7ac8446

package/src/session/session.ts

@@ -2,27 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Option, Schema } from 'effect';
-
-import {
-  defineTool,
-  Message,
-  structuredOutputParser,
-  ToolResult,
-  type ArtifactDefinition,
-  type MessageContentBlock,
-  type Tool,
-} from '@dxos/artifact';
+import { Schema as S } from 'effect';
+
+import { defineTool, Message, ToolResult, type ArtifactDefinition, type Tool } from '@dxos/artifact';
 import { Event, synchronized } from '@dxos/async';
-import { ObjectVersion } from '@dxos/echo-db';
-import { create, type ObjectId } from '@dxos/echo-schema';
+import { createStatic } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 
-import { isToolUse, runTools } from './tools';
-import { VersionPin } from './version-pin';
 import { MixedStreamParser, type AIServiceClient, type GenerateRequest, type GenerationStream } from '../ai-service';
-
+import { isToolUse, runTools } from '../conversation';
 /**
  * Contains message history, tools, current context.
  * Current context means the state of the app, time of day, and other contextual information.
@@ -34,22 +23,6 @@ import { MixedStreamParser, type AIServiceClient, type GenerateRequest, type Gen
  * Could be personal or shared.
  */
 
-/**
- * Resolves artifact ids to their versions.
- * Used to give the model a sense of the changes to the artifacts made by users during the conversation.
- * The artifacts versions are pinned in the history, and whenever the artifact changes in-between assistant's steps,
- * a diff is inserted into the conversation.
- */
-export type ArtifactDiffResolver = (artifacts: { id: ObjectId; lastVersion: ObjectVersion }[]) => Promise<
-  Map<
-    ObjectId,
-    {
-      version: ObjectVersion;
-      diff?: string;
-    }
-  >
->;
-
 export type SessionRunOptions = {
   client: AIServiceClient;
 
@@ -74,22 +47,15 @@ export type SessionRunOptions = {
    * Pre-require artifacts.
    */
   requiredArtifactIds?: string[];
-
-  /**
-   * @see ArtifactDiffResolver
-   */
-  artifactDiffResolver?: ArtifactDiffResolver;
 };
 
-type OperationModel = 'planning' | 'importing' | 'configured';
+type OperationModel = 'planning' | 'immediate';
 
 export type AiSessionOptions = {
   /**
-   * Determines the agent's handling of the artifacts definitions:
-   *
-   * - `planning`: The model will create a plan with required artifacts for each step.
-   * - `importing`: The model can query registry and only pull in the artifacts that are required to complete the task.
-   * - `configured`: The available artifacts are pre-selected and the model cannot select additional artifacts.
+   * In planning mode, the model will create a plan before executing the user's request.
+   * The plan will determine the artifacts that will be used to perform the actions.
+   * In require mode, the model will select the artifacts that will be used to perform the actions.
    */
   operationModel: OperationModel;
 };
@@ -138,30 +104,147 @@ export class AISession {
 
   @synchronized
   async run(options: SessionRunOptions): Promise<Message[]> {
-    const systemTools: Tool[] = [];
+    const systemTools: Tool[] = [
+      defineTool('system', {
+        name: 'query_artifact_definitions',
+        description: 'Query the available artifact definitions',
+        schema: S.Struct({}),
+        execute: async () => {
+          return ToolResult.Success({
+            artifactDefinitions: options.artifacts.map((artifact) => ({
+              id: artifact.id,
+              name: artifact.name,
+              description: artifact.description,
+            })),
+          });
+        },
+      }),
+    ];
     switch (this._options.operationModel) {
       case 'planning':
-        systemTools.push(this._createQueryArtifactsTool(options.artifacts), this._createPlanningTool(options));
-        break;
-      case 'importing':
         systemTools.push(
-          this._createQueryArtifactsTool(options.artifacts),
-          this._createRequireTool(options.artifacts, (artifactDefinitionIds) => {
-            for (const artifactDefinitionId of artifactDefinitionIds) {
-              requiredArtifactIds.add(artifactDefinitionId);
-            }
+          defineTool('system', {
+            name: 'create_plan',
+            description:
+              'Create a plan. Make sure that each step is independent and can be executed solely on the data returned by the previous step. The steps only share the data that is specified in the plan.',
+            schema: S.Struct({
+              goal: S.String.annotations({ description: 'The goal that the plan will achieve.' }),
+              steps: S.Array(
+                S.Struct({
+                  action: S.String.annotations({
+                    description: 'Complete, detailed action to perform.',
+                  }),
+                  input: S.String.annotations({
+                    description: 'The required input data for this step. First step must not require any data.',
+                  }),
+                  output: S.String.annotations({
+                    description: 'The output data from this step. This is passed to the next step as input.',
+                  }),
+                  requiredArtifactIds: S.Array(S.String).annotations({
+                    description: 'The ids of the artifacts required to perform this step.',
+                    examples: [['artifact:dxos.org/example/Test']],
+                  }),
+                }),
+              ).annotations({ description: 'Steps' }),
+            }),
+            execute: async ({ goal, steps }) => {
+              const missingArtifactIds = steps
+                .flatMap((step) => step.requiredArtifactIds)
+                .filter((artifactId) => !options.artifacts.some((artifact) => artifact.id === artifactId));
+              if (missingArtifactIds.length > 0) {
+                return ToolResult.Error(`One or more artifact ids are invalid: ${missingArtifactIds.join(', ')}`);
+              }
+
+              const stepResults: any[] = [];
+              for (const step of steps) {
+                log('executing step', { action: step.action });
+                const session = new AISession({ operationModel: 'immediate' });
+                session.message.on((ev) => this.message.emit(ev));
+                session.block.on((ev) => this.block.emit(ev));
+                session.update.on((ev) => this.update.emit(ev));
+                session.streamEvent.on((ev) => this.streamEvent.emit(ev));
+                session.userMessage.on((ev) => this.userMessage.emit(ev));
+
+                const messages = await session.run({
+                  client: options.client,
+                  artifacts: options.artifacts,
+                  tools: options.tools,
+                  history: options.history,
+                  extensions: options.extensions,
+                  generationOptions: options.generationOptions,
+                  requiredArtifactIds: step.requiredArtifactIds.slice(),
+                  prompt: `
+                    You are an agent that executes the subtask in a plan.
+                    
+                    While you know the plan's goal only focus on your subtask
+                    Use the data from the previous step to complete your task.
+                    Return all of the data from "output" in your last message.
+                    
+                    Current step (that you need to complete):
+                    ${JSON.stringify(
+                      {
+                        goal,
+                        input: step.input,
+                        output: step.output,
+                        yourTask: step.action,
+                      },
+                      null,
+                      2,
+                    )}
+                    
+                    Previous step results:
+                    ${JSON.stringify(stepResults.at(-1))}.
+                  `,
+                });
+                const result = messages.at(-1);
+                stepResults.push(result);
+              }
+
+              return ToolResult.Success({ stepResults });
+            },
           }),
         );
         break;
-      case 'configured':
-        // no system tools
+      case 'immediate':
+        systemTools.push(
+          defineTool('system', {
+            name: 'require_artifact_definitions',
+            description:
+              'Require the use of specific artifact definitions. This will allow the model to interact with artifact definitions and use their tools.',
+            schema: S.Struct({
+              artifactDefinitionIds: S.Array(S.String).annotations({
+                description: 'The ids of the artifact definitions to require',
+                examples: [['artifact:dxos.org/example/Test']],
+              }),
+            }),
+            execute: async ({ artifactDefinitionIds }) => {
+              const missingArtifactDefinitionIds = artifactDefinitionIds.filter(
+                (artifactId) => !options.artifacts.some((artifact) => artifact.id === artifactId),
+              );
+              if (missingArtifactDefinitionIds.length > 0) {
+                return ToolResult.Error(
+                  `One or more artifact definition ids are invalid: ${missingArtifactDefinitionIds.join(', ')}`,
+                );
+              }
+
+              for (const artifactDefinitionId of artifactDefinitionIds) {
+                requiredArtifactIds.add(artifactDefinitionId);
+              }
+
+              return ToolResult.Success({});
+            },
+          }),
+        );
         break;
-      default:
-        throw new TypeError(`Invalid operation model: ${this._options.operationModel}`);
     }
 
     this._history = [...options.history];
-    this._pending = [await this._formatUserPrompt(options.artifactDiffResolver, options.prompt, options.history)];
+    this._pending = [
+      createStatic(Message, {
+        role: 'user',
+        content: [{ type: 'text', text: options.prompt }],
+      }),
+    ];
     this.userMessage.emit(this._pending.at(-1)!);
     this._stream = undefined;
     let error: Error | undefined;
@@ -185,7 +268,7 @@ export class AISession {
         });
 
         // Open request stream.
-        this._stream = await options.client.execStream({
+        this._stream = await options.client.exec({
           ...(options.generationOptions ?? {}),
           // TODO(burdon): Rename messages or separate history/message.
           history: [...this._history, ...this._pending],
@@ -231,7 +314,7 @@ export class AISession {
     } catch (err) {
       log.catch(err);
       if (err instanceof Error && err.message.includes('Overloaded')) {
-        error = new AIServiecOverloadedError('AI service overloaded', { cause: err } as any); // TODO(dmaretskyi): Schema errors cant have cause
+        error = new AIServiecOverloadedError('AI service overloaded', { cause: err });
       } else {
         error = new Error('AI service error', { cause: err });
       }
@@ -246,185 +329,6 @@ export class AISession {
     return this._pending;
   }
 
-  async runStructured<S extends Schema.Schema.AnyNoContext>(schema: S, options: SessionRunOptions) {
-    const parser = structuredOutputParser(schema);
-    const result = await this.run({
-      ...options,
-      tools: [...options.tools, parser.tool],
-    });
-    return parser.getResult(result);
-  }
-
-  private async _formatUserPrompt(
-    artifactDiffResolver: ArtifactDiffResolver | undefined,
-    prompt: string,
-    history: Message[],
-  ) {
-    const prelude: MessageContentBlock[] = [];
-
-    if (artifactDiffResolver) {
-      const versions = gatherObjectVersions(history);
-
-      const artifactDiff = await artifactDiffResolver(
-        Array.from(versions.entries()).map(([id, version]) => ({ id, lastVersion: version })),
-      );
-
-      log.info('vision', {
-        artifactDiff,
-        versions,
-      });
-
-      for (const [id, { version }] of [...artifactDiff.entries()]) {
-        if (ObjectVersion.equals(version, versions.get(id)!)) {
-          artifactDiff.delete(id);
-          continue;
-        }
-
-        prelude.push(VersionPin.createBlock(VersionPin.make({ objectId: id, version })));
-      }
-      if (artifactDiff.size > 0) {
-        prelude.push(createArtifactUpdateBlock(artifactDiff));
-      }
-    }
-
-    return create(Message, {
-      role: 'user',
-      content: [...prelude, { type: 'text', text: prompt }],
-    });
-  }
-
-  private _createQueryArtifactsTool(artifacts: ArtifactDefinition[]) {
-    return defineTool('system', {
-      name: 'query_artifact_definitions',
-      description: 'Query the available artifact definitions',
-      schema: Schema.Struct({}),
-      execute: async () => {
-        return ToolResult.Success({
-          artifactDefinitions: artifacts.map((artifact) => ({
-            id: artifact.id,
-            name: artifact.name,
-            description: artifact.description,
-          })),
-        });
-      },
-    });
-  }
-
-  private _createRequireTool(
-    artifacts: ArtifactDefinition[],
-    onRequire: (artifactDefinitionIds: readonly string[]) => void,
-  ) {
-    return defineTool('system', {
-      name: 'require_artifact_definitions',
-      description:
-        'Require the use of specific artifact definitions. This will allow the model to interact with artifact definitions and use their tools.',
-      schema: Schema.Struct({
-        artifactDefinitionIds: Schema.Array(Schema.String).annotations({
-          description: 'The ids of the artifact definitions to require',
-          examples: [['artifact:dxos.org/example/Test']],
-        }),
-      }),
-      execute: async ({ artifactDefinitionIds }) => {
-        const missingArtifactDefinitionIds = artifactDefinitionIds.filter(
-          (artifactId) => !artifacts.some((artifact) => artifact.id === artifactId),
-        );
-        if (missingArtifactDefinitionIds.length > 0) {
-          return ToolResult.Error(
-            `One or more artifact definition ids are invalid: ${missingArtifactDefinitionIds.join(', ')}`,
-          );
-        }
-
-        onRequire(artifactDefinitionIds);
-
-        return ToolResult.Success({});
-      },
-    });
-  }
-
-  private _createPlanningTool(options: SessionRunOptions) {
-    return defineTool('system', {
-      name: 'create_plan',
-      description:
-        'Create a plan. Make sure that each step is independent and can be executed solely on the data returned by the previous step. The steps only share the data that is specified in the plan.',
-      schema: Schema.Struct({
-        goal: Schema.String.annotations({ description: 'The goal that the plan will achieve.' }),
-        steps: Schema.Array(
-          Schema.Struct({
-            action: Schema.String.annotations({
-              description: 'Complete, detailed action to perform.',
-            }),
-            input: Schema.String.annotations({
-              description: 'The required input data for this step. First step must not require any data.',
-            }),
-            output: Schema.String.annotations({
-              description: 'The output data from this step. This is passed to the next step as input.',
-            }),
-            requiredArtifactIds: Schema.Array(Schema.String).annotations({
-              description: 'The ids of the artifacts required to perform this step.',
-              examples: [['artifact:dxos.org/example/Test']],
-            }),
-          }),
-        ).annotations({ description: 'Steps' }),
-      }),
-      execute: async ({ goal, steps }) => {
-        const missingArtifactIds = steps
-          .flatMap((step) => step.requiredArtifactIds)
-          .filter((artifactId) => !options.artifacts.some((artifact) => artifact.id === artifactId));
-        if (missingArtifactIds.length > 0) {
-          return ToolResult.Error(`One or more artifact ids are invalid: ${missingArtifactIds.join(', ')}`);
-        }
-
-        const stepResults: any[] = [];
-        for (const step of steps) {
-          log('executing step', { action: step.action });
-          const session = new AISession({ operationModel: 'importing' });
-          session.message.on((ev) => this.message.emit(ev));
-          session.block.on((ev) => this.block.emit(ev));
-          session.update.on((ev) => this.update.emit(ev));
-          session.streamEvent.on((ev) => this.streamEvent.emit(ev));
-          session.userMessage.on((ev) => this.userMessage.emit(ev));
-
-          const messages = await session.run({
-            client: options.client,
-            artifacts: options.artifacts,
-            tools: options.tools,
-            history: options.history,
-            extensions: options.extensions,
-            generationOptions: options.generationOptions,
-            requiredArtifactIds: step.requiredArtifactIds.slice(),
-            artifactDiffResolver: options.artifactDiffResolver,
-            prompt: `
-              You are an agent that executes the subtask in a plan.
-              
-              While you know the plan's goal only focus on your subtask
-              Use the data from the previous step to complete your task.
-              Return all of the data from "output" in your last message.
-              
-              Current step (that you need to complete):
-              ${JSON.stringify(
-                {
-                  goal,
-                  input: step.input,
-                  output: step.output,
-                  yourTask: step.action,
-                },
-                null,
-                2,
-              )}
-              
-              Previous step results:
-              ${JSON.stringify(stepResults.at(-1))}.
-            `,
-          });
-          const result = messages.at(-1);
-          stepResults.push(result);
-        }
-
-        return ToolResult.Success({ stepResults });
-      },
-    });
-  }
-
   abort() {
     this._stream?.abort();
   }
@@ -447,75 +351,25 @@ const createBaseInstructions = ({
   Decision-making:
 
   - Analyze the structure and type of the content in the user's message.
-  
-  
+  - Can you complete the task using the available artifacts?
+  - If you can't complete the task using the available artifacts, query the list of available artifacts using the appropriate tool.
+  - Identify which artifacts are relevant to the user's request.
   ${
     operationModel === 'planning'
       ? `
-      - Can you complete the task using the available artifacts?
-      - If you can't complete the task using the available artifacts, query the list of available artifacts using the appropriate tool.
-      - Identify which artifacts are relevant to the user's request.
         - Break down the user's request into a step-by-step plan that you will use to execute the user's request, the plan items should include artifacts which will be used to perform the actions.
       `
-      : ''
-  }
-  ${
-    operationModel === 'importing'
-      ? `
-      - Can you complete the task using the available artifacts?
-      - If you can't complete the task using the available artifacts, query the list of available artifacts using the appropriate tool.
-      - Identify which artifacts are relevant to the user's request.
-    - Are the required artifacts already available?
-    - If not, select which artifact(s) will be the most relevant and require them using the require_artifacts tool.
-    - The require'd artifact tools will be available for use after require.
-  `
-      : ''
-  }
-  ${
-    operationModel === 'configured'
-      ? `
-    - Select the most relevant artifact(s) to complete the task.
-    - Call the appropriate tool to use the artifact(s).
-  `
-      : ''
+      : `
+      - Are the required artifacts already available?
+      - If not, select which artifact(s) will be the most relevant and require them using the require_artifacts tool.
+      - The require'd artifact tools will be available for use after require.
+    `
   }
 
   ${availableArtifacts.length > 0 ? `Artifacts already in context: ${availableArtifacts.join('\n')}` : ''}
 `;
 
-export class AIServiecOverloadedError extends Schema.TaggedError<AIServiecOverloadedError>()(
+export class AIServiecOverloadedError extends S.TaggedError<AIServiecOverloadedError>()(
   'AIServiecOverloadedError',
   {},
 ) {}
-
-const gatherObjectVersions = (messages: Message[]): Map<ObjectId, ObjectVersion> => {
-  const artifactIds = new Map<ObjectId, ObjectVersion>();
-  for (const message of messages) {
-    for (const block of message.content) {
-      if (block.type === 'json' && block.disposition === VersionPin.DISPOSITION) {
-        const pin = VersionPin.pipe(Schema.decodeOption)(JSON.parse(block.json)).pipe(Option.getOrUndefined);
-        if (!pin) {
-          continue;
-        }
-        artifactIds.set(pin.objectId, pin.version);
-      }
-    }
-  }
-
-  return artifactIds;
-};
-
-const createArtifactUpdateBlock = (
-  artifactDiff: Map<ObjectId, { version: ObjectVersion; diff?: string }>,
-): MessageContentBlock => {
-  return {
-    type: 'text',
-    disposition: 'artifact-update',
-    text: `
-      The following artifacts have been updated since the last message:
-      ${Array.from(artifactDiff.entries())
-        .map(([id, { diff }]) => `<changed-artifact id="${id}">${diff ? `\n${diff}` : ''}</changed-artifact>`)
-        .join('\n')}
-    `,
-  };
-};

package/src/testing/artifacts.test.ts

@@ -3,7 +3,7 @@
 //
 
 /*
-import { Schema } from '@effect/schema';
+import { Schema as S } from '@effect/schema';
 import { describe, test } from 'vitest';
 
 import { ObjectId, toJsonSchema } from '@dxos/echo-schema';
@@ -15,26 +15,26 @@ import { AIServiceEdgeClient, Tool } from '../ai-service';
 import { defineTool, ToolResult } from '../conversation';
 
 // TODO(dmaretskyi): Effect schema.
-const ArtifactDef = Schema.Struct({
-  typename: Schema.String,
-  description: Schema.String,
-  schema: Schema.Any,
-  actions: Schema.Array(Tool),
-}).pipe(Schema.mutable);
+const ArtifactDef = S.Struct({
+  typename: S.String,
+  description: S.String,
+  schema: S.Any,
+  actions: S.Array(Tool),
+}).pipe(S.mutable);
 
-type ArtifactDef = Schema.Schema.Type<typeof ArtifactDef>;
+type ArtifactDef = S.Schema.Type<typeof ArtifactDef>;
 
-const ListItem = Schema.Struct({
-  name: Schema.String,
+const ListItem = S.Struct({
+  name: S.String,
 });
 
-const ListSchema = Schema.Struct({
+const ListSchema = S.Struct({
   id: ObjectId,
-  title: Schema.String,
-  items: Schema.Array(ListItem).pipe(Schema.mutable),
-}).pipe(Schema.mutable);
+  title: S.String,
+  items: S.Array(ListItem).pipe(S.mutable),
+}).pipe(S.mutable);
 
-type ListSchema = Schema.Schema.Type<typeof ListSchema>;
+type ListSchema = S.Schema.Type<typeof ListSchema>;
 
 const list: ArtifactDef = {
   typename: 'example.com/type/List',
@@ -44,7 +44,7 @@ const list: ArtifactDef = {
     defineTool('list', {
       name: 'query',
       description: 'Query all lists',
-      schema: Schema.Struct({}),
+      schema: S.Struct({}),
       execute: async ({}, context) => {
         return ToolResult.Success(LISTS[id]);
       },
@@ -52,7 +52,7 @@ const list: ArtifactDef = {
     defineTool('list', {
       name: 'inspect',
       description: 'Get contents of the list',
-      schema: Schema.Struct({
+      schema: S.Struct({
         id: ObjectId.annotations({ description: 'The list to inspect' }),
       }),
       execute: async ({ id }, context) => {
@@ -62,9 +62,9 @@ const list: ArtifactDef = {
     defineTool('list', {
       name: 'create',
       description: 'Add one or more items to an existing list',
-      schema: Schema.Struct({
+      schema: S.Struct({
         id: ObjectId.annotations({ description: 'The list to add items to' }),
-        items: Schema.Array(ListItem).annotations({ description: 'The items to add to the list' }),
+        items: S.Array(ListItem).annotations({ description: 'The items to add to the list' }),
       }),
       execute: async ({ id, items }, context) => {
         LISTS[id].items.push(...items);
@@ -81,7 +81,7 @@ const artifacts = [list];
 const getArtifactDefinitions = defineTool('system', {
   name: 'getArtifactDefinitions',
   description: 'Queries the definitions and metadata of artifacts defined in the system',
-  schema: Schema.Any,
+  schema: S.Any,
   execute: async (_, context) => {
     return ToolResult.Success(
       artifacts.map((artifact) => ({
@@ -116,8 +116,8 @@ describe('Artifacts', () => {
       name: 'custodian',
       description: 'Custodian can tell you the password if you say the magic word',
       parameters: toJsonSchema(
-        Schema.Struct({
-          magicWord: Schema.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
+        S.Struct({
+          magicWord: S.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
         }),
       ),
     };

package/src/testing/index.ts

@@ -5,7 +5,6 @@
 export * from './defs';
 export * from './logger';
 export * from './ollama';
-export * from './printer';
 export * from './query-promts';
 export * from './test-data';
 export * from './test-schema';

package/src/testing/logger.ts

@@ -4,7 +4,7 @@
 
 import type { ImageSource, MessageContentBlock } from '@dxos/artifact';
 
-import type { ConversationEvent } from '../experimental';
+import type { ConversationEvent } from '../conversation';
 
 export const createLogger = ({
   stream,

package/src/testing/query-promts.ts

@@ -2,23 +2,23 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 
 import { defineTool, ToolResult } from '@dxos/artifact';
 import { toJsonSchema } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
 
-import { executeQuery, formatJsonSchemaForLLM, type DataSource } from '../experimental';
+import { executeQuery, formatJsonSchemaForLLM, type DataSource } from '../cypher';
 import { trim } from '../util';
 
-export const createCypherTool = (dataSource: DataSource, schemaTypes: Schema.Schema.Any[] = []) =>
+export const createCypherTool = (dataSource: DataSource, schemaTypes: S.Schema.Any[] = []) =>
   defineTool('dxos.org/echo', {
     name: 'query',
     description:
       'Query the ECHO graph database in cypher query language. Returns data from the database.' +
       (schemaTypes.length > 0 ? `\n\n${createSystemPrompt(schemaTypes)}` : ''),
-    schema: Schema.Struct({
-      query: Schema.String.annotations({
+    schema: S.Struct({
+      query: S.String.annotations({
         description: `
           A valid cypher query string to execute.
           Query must have one MATCH clause.
@@ -55,7 +55,7 @@ export const createCypherTool = (dataSource: DataSource, schemaTypes: Schema.Sch
     },
   });
 
-export const createSystemPrompt = (schemaTypes: Schema.Schema.Any[]) => trim`
+export const createSystemPrompt = (schemaTypes: S.Schema.Any[]) => trim`
   You have access to ECHO graph database. You can query the database to get data to satisfy user prompts.
 
   Database schema is defined in pseud-cypher syntax. The schema is: