Use AI Prompts in Jupyter

Intro

Jupyter Workspaces allows you to write AI prompts within Notebooks. Jupyter uses the same prompts as in the Domo. AI Playground without navigating away from Jupyter. Learn more about Jupyter AI and the AI Playground.

Required Grants

To access Jupyter, at least one of the following grants must be enabled for your role:

Create Jupyter Workspace — Allows a user to create, edit, and delete Jupyter Workspaces to which they have access.
Manage Jupyter Workspace (Jupyter Admin) — Allows a user to view, edit, and delete any Jupyter Workspaces in the instance. This grant is needed to enable workspace sharing for other users.

Access Jupyter Workspaces

In the navigation header, select Data to open the Data Center. In the left navigation, select

More (three horizontal dots icon) > Jupyter Workspaces.

Learn more about creating a Workspace.

Use the Generate Text Prompt

The generate_text prompt provides answers to questions. In the example, the prompt provided to the AI service is in the prompt_template. It is given a limitation of $, which is provided in the prompt_parameters. The output prompt is provided at the bottom.

When a prompt_template is included, it will ignore the input_str unless you include the placeholder ${input} within your prompt template text. If you include the ${input} placeholder, then the input_str will automatically be inserted for that placeholder. The following parameters are available in the generate_text function. All of the parameters are optional except input_str.

def generate_text(input_str:str,  
          prompt_template: Optional[PromptTemplate] = None,  
          parameters: Optional[dict[str, str]] = None,  
          model: Optional[str] = None,  
          model_configuration: Optional[dict[str, object]] = None,  
          system: Optional[str] = None):  
  """      
  Generate text from String input  
    
  Parameters:          
    input_str (str): input string          
    prompt_template (PromptTemplate): prompt template          
    parameters (dict[str, str]): parameters          
    model (str): model name          
    model_configuration (dict[str, object]): model configuration          
    system (str): Optional override for the default system instructions included with the prompt to the model.  
      
  Returns:          
    response: generated text      
  """  
  text_generation_request = TextGenerationRequest(input_str, prompt_template, parameters, model,  
model_configuration, system)  
 text_response = _jupyterhub.generate_text(text_generation_request.to_json())  
text_ai_response = TextAIResponse(text_response['prompt'], text_response['choices'])  
return text_ai_response

Use the Text-to-SQL Prompt

The text_to_sql prompt provides a SQL query based on the question asked. In the example, the prompt provided to the AI service is in the prompt_template, and the specified column is in the prompt_parameters. The functional SQL query is provided in the output at the bottom.

You can modify the standard text_to_sql template by providing a new DataSourceSchema and an input_str that specifies what the AI prompt should write. You can also provide the workspace_data_source_alias for an existing DataSet attached to the workspace. Providing the workspace_data_source_alias allows the workspace to use the schema when generating the column names for the SQL query. The following parameters are available in the text_to_sql function. All of the parameters are optional except input_str.

def text_to_sql(input_str: str,                  
         prompt_template: Optional[PromptTemplate] = None,                  
         data_source_schemas: Optional[list[DataSourceSchema]] = None,                 
         parameters: Optional[dict[str, str]] = None,                  
         model: Optional[str] = None,                  
         model_configuration: Optional[dict[str, object]] = None,                  
         workspace_data_source_alias: Optional[str] = None,                  
         dataframe: Optional[pd.DataFrame] = None,                  
         system: Optional[str] = None                  
         ):     
   """      
   Convert text to SQL  
     
   Parameters:         
     input_str (str): input string          
     data_source_schemas (list[DataSourceSchema]): list of data source schemas          
     prompt_template (PromptTemplate): prompt template          
     parameters (dict[str, str]): parameters          
     model (str): model name          
     model_configuration (dict[str, object]): model configuration          
     workspace_data_source_alias (str): data source schema alias associated to workspace          
     dataframe (pd.DataFrame): Pandas dataframe          
     system (str): Optional override for the default system instructions included with the prompt to the model.  
     
   Returns:          
     text_ai_response: TextAiResponse      
   """   if workspace_data_source_alias is not None:         
      data_source_schemas = [              
        DataSourceSchema.from_optional_list(domojupyter.io.get_schema_from_datasource(workspace_data_source_alias).get('schema'),                  
          workspace_data_source_alias)]      
   elif dataframe is not None:          
      schema = domojupyter.io.get_schema_from_dataframe(dataframe)          
      data_source_schemas = [              
        DataSourceSchema.from_optional_list(schema,                  
          dataframe.name)]      
   text_to_sql_request = TextToSQLRequest(input_str, data_source_schemas, prompt_template, parameters, model,                                             
                         model_configuration, system)      
   sql_response = _jupyterhub.text_to_sql(text_to_sql_request.to_json())      
   text_ai_response = TextAIResponse(sql_response['prompt'], sql_response['choices'])      
   return text_ai_response

Use the Text-to-Beast-Mode Prompt

The Text-to-Beast-Mode service provides a Beast Mode function based on the question asked. In the example, the prompt provided to the AI asks to add all of the value columns (data_source_schemas) together. The Beast Mode function is provided in the output at the bottom.

The following parameters are available in the text_to_beast_mode function. All of the parameters are optional except input_str.

def text_to_beast_mode(input_str: str,  
         prompt_template: Optional[PromptTemplate] = None,                         
         data_source_schema: Optional[DataSourceSchema] = None,                         
         parameters: Optional[dict[str, str]] = None,                         
         model: Optional[str] = None,                         
         model_configuration: Optional[dict[str, object]] = None,                         
         system: Optional[str] = None):      
  """      
  Convert text to Beastmode  
      
  Parameters:         
      input_str (str): input string          
      data_source_schema (DataSourceSchema): data source schema          
      prompt_template (PromptTemplate): prompt          
      parameters (dict[str, str]): parameters          
      model (str): model name          
      model_configuration (dict[str, object]): model configuration          
      system (str): Optional override for the default system instructions included with the prompt to the model.  
      
  Returns:          
    sql: SQL string      
  """

Use the Summarize Text Prompt

The summarize_text prompt provides a text summary based on the question asked. In the example, the prompt provided to the AI service is in text_summarization. The output prompt is provided at the bottom.

Screenshot 2024-09-18 at 11.30.03 AM.png

The following parameters are available in the summarize_text function. All of the parameters are optional except input_str.

def summarize(input_str: str,                
       prompt_template: Optional[PromptTemplate] = None,                
       parameters: Optional[dict[str, str]] = None,                
       model: Optional[str] = None,                
       model_configuration: Optional[dict[str, object]] = None,                
       system: Optional[str] = None,                
       chunking_configuration: Optional[ChunkingConfiguration] = None,                
       output_style: Optional[SummarizationOutputStyle] = None,                
       output_word_length: Optional[SizeBoundary] = None):      
  """      
  Summarize text  
    
  Parameters:          
      input_str (str): Text information to be summarized. This attribute is mandatory.          
      prompt_template (PromptTemplate): prompt template          
      parameters (dict): A dictionary containing parameter-name and its corresponding value.              
        It's used for replacing the placeholders in the PromptTemplate.          
      model (str): Name/id of the language model to be used for summarization          
      model_configuration (dict): A dictionary with custom configuration parameters for a selected language model.          
      system (str): Optional override for the default system instructions included with the prompt to the model.          
      chunking_configuration (ChunkingConfiguration): Configuration for dividing the given text into smaller parts or chunks.          
      output_style (SummarizationOutputStyle): Determines the design, structuring and organization of the summarization's output.          
      output_word_length (SizeBoundary): Defines a size boundary to limit the length of the output summary, based on number of words.  
      
  Returns:          
    response: summarized text      
  """

Note: The parameter behavior described below should be confirmed against the current product. This content was submitted for PM review.

The summarize() function generates a summary from a long block of text using an AI model. It supports optional configurations that control the style, structure, and length of the summary. The only required parameter is input_str.

summarize(input_str="Paste your text here...")

Optional Parameters

prompt_template

prompt_template (Optional) — The PromptTemplate class helps structure reusable prompt strings for AI tasks. In this implementation, it is lightweight, requiring only a single input: the full prompt text.

from domojupyter.ai.models.PromptTemplate import PromptTemplate

template_text = "Summarize the following text:\n{text}"
prompt = PromptTemplate(template=template_text)

parameters

parameters (Optional) — A dictionary used to replace placeholders in the prompt_template.

parameters = {
    "topic": "monthly sales report",
    "audience": "executive leadership"
}

model and model_configuration

model (Optional) — Name or ID of the language model to be used for summarization.
model_configuration (Optional) — A dictionary with custom configuration parameters for a selected language model.

chunking_configuration

chunking_configuration (Optional) — Use this when summarizing large blocks of text. It splits the text into smaller, manageable chunks before summarization.

from domojupyter.ai.models.ChunkingConfiguration import ChunkingConfiguration
from domojupyter.ai.models.SeparatorType import SeparatorType

chunking_configuration = ChunkingConfiguration(
    max_chunk_size=1000,
    chunk_overlap=100,
    separators=["\n\n", "\n", " "],
    separator_type=SeparatorType.TEXT,
    disallow_intermediate_chunks=False
)

Available SeparatorType options: CPP, GO, HTML, JAVA, JAVASCRIPT, LATEX, MARKDOWN, PROTO, PYTHON, RST, RUBY, SCALA, SOL, SWIFT, TEXT.

output_style

output_style (Optional) — Determines the design, structuring, and organization of the summarization’s output.

from domojupyter.ai.models.SummarizationOutputStyle import SummarizationOutputStyle

output_style = SummarizationOutputStyle.BULLETED  # Options: BULLETED, NUMBERED, PARAGRAPH

output_word_length

output_word_length (Optional) — Defines a size boundary to limit the length of the output summary, based on number of words.

from domojupyter.ai.models.SizeBoundary import SizeBoundary

output_word_length = SizeBoundary(min_bound=75, max_bound=150)

Example

The following example combines several optional parameters.

from domojupyter.ai.models.ChunkingConfiguration import ChunkingConfiguration
from domojupyter.ai.models.SeparatorType import SeparatorType
from domojupyter.ai.models.SummarizationOutputStyle import SummarizationOutputStyle
from domojupyter.ai.models.SizeBoundary import SizeBoundary

summary = summarize(
    input_str=long_text,
    output_style=SummarizationOutputStyle.BULLETED,
    output_word_length=SizeBoundary(min_bound=75, max_bound=150),
    chunking_configuration=ChunkingConfiguration(
        max_chunk_size=1200,
        chunk_overlap=100,
        separators=["\n", ".", " "],
        separator_type=SeparatorType.MARKDOWN,
        disallow_intermediate_chunks=False
    )
)

Getting Started

Domo Free

Connect & Integrate

Transform & Manage

Visualize & Interact

AI & Data Science

Automate

Distribute

Admin

General Information

Use AI Prompts in Jupyter

Intro

Required Grants

Access Jupyter Workspaces

Use the Generate Text Prompt

Use the Text-to-SQL Prompt

Use the Text-to-Beast-Mode Prompt

Use the Summarize Text Prompt

Optional Parameters

prompt_template

parameters

model and model_configuration

chunking_configuration

output_style

output_word_length

Example

​Intro

​Required Grants

​Access Jupyter Workspaces

​Use the Generate Text Prompt

​Use the Text-to-SQL Prompt

​Use the Text-to-Beast-Mode Prompt

​Use the Summarize Text Prompt

​Optional Parameters

​prompt_template

​parameters

​model and model_configuration

​chunking_configuration

​output_style

​output_word_length

​Example

Intro

Required Grants

Access Jupyter Workspaces

Use the Generate Text Prompt

Use the Text-to-SQL Prompt

Use the Text-to-Beast-Mode Prompt

Use the Summarize Text Prompt

Optional Parameters

prompt_template

parameters

model and model_configuration

chunking_configuration

output_style

output_word_length

Example