Creative Director GPT

Creative Director GPT · GPT-Aktionen

Varied and Engaging Writing API

API for generating varied and engaging writing using rules for sentence structure and length.

    Ursprüngliches API-Schema
    {
      "openapi": "3.1.0",
      "info": {
        "title": "Varied and Engaging Writing API",
        "version": "1.0.0",
        "description": "API for generating varied and engaging writing using rules for sentence structure and length."
      },
      "servers": [
        {
          "url": "https://api.mistral.ai/v1",
          "description": "Production server"
        }
      ],
      "paths": {
        "/chat/completions/": null
      },
      "components": {
        "schemas": {
          "WritingRules": {
            "type": "object",
            "properties": {
              "rules": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "name": {
                      "type": "string",
                      "description": "The name of the rule."
                    },
                    "description": {
                      "type": "string",
                      "description": "The description of the rule."
                    },
                    "logic": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "condition": {
                            "type": "string",
                            "description": "The condition to trigger the action."
                          },
                          "criteria": {
                            "type": "object",
                            "properties": {
                              "type": {
                                "type": "string",
                                "description": "The type of criteria to evaluate."
                              },
                              "operator": {
                                "type": "string",
                                "description": "The operator for the criteria evaluation."
                              },
                              "value": {
                                "type": "integer",
                                "description": "The value to compare against the criteria."
                              }
                            },
                            "required": [
                              "type",
                              "operator",
                              "value"
                            ]
                          },
                          "action": {
                            "type": "string",
                            "description": "The action to take if the condition is met."
                          }
                        },
                        "required": [
                          "condition",
                          "action"
                        ]
                      }
                    }
                  },
                  "required": [
                    "name",
                    "description",
                    "logic"
                  ]
                }
              }
            }
          }
        }
      },
      "rules": [
        {
          "name": "Avoid Monotony",
          "description": "Short sentences are acceptable but using them consecutively creates a monotonous rhythm. Mix sentence lengths to maintain the reader's interest.",
          "logic": [
            {
              "condition": "if",
              "criteria": {
                "type": "consecutive_short_sentences",
                "operator": ">",
                "value": 3
              },
              "action": "vary_sentence_length"
            }
          ]
        },
        {
          "name": "Create Variety",
          "description": "Alternate between short, medium, and long sentences. Use a combination to create a pleasant rhythm and flow.",
          "logic": [
            {
              "condition": "after_short_sentence",
              "action": "use_medium_or_long_sentence"
            },
            {
              "condition": "after_medium_sentence",
              "action": "use_short_or_long_sentence"
            },
            {
              "condition": "after_long_sentence",
              "action": "use_short_or_medium_sentence"
            }
          ]
        },
        {
          "name": "Engage the Reader",
          "description": "Use shorter sentences to create emphasis or impact. Use medium-length sentences for clarity and detail. Use longer sentences to build energy, provide depth, and create a sense of climax.",
          "logic": [
            {
              "condition": "emphasize_point",
              "action": "use_short_sentence"
            },
            {
              "condition": "explain_detail",
              "action": "use_medium_sentence"
            },
            {
              "condition": "build_climax",
              "action": "use_long_sentence"
            }
          ]
        },
        {
          "name": "Write with Rhythm",
          "description": "Think of writing as creating music; it should have harmony and melody. Vary sentence structure to keep the reader engaged and create a pleasing auditory experience.",
          "logic": [
            {
              "condition": "monotonous_flow_detected",
              "action": "introduce_varied_sentence_structure"
            }
          ]
        },
        {
          "name": "Use Sentences Purposefully",
          "description": "Short sentences for key points or dramatic effect. Medium sentences for explanation and narrative. Long sentences to build momentum and convey complex ideas.",
          "logic": [
            {
              "condition": "key_point",
              "action": "use_short_sentence"
            },
            {
              "condition": "detailed_explanation",
              "action": "use_medium_sentence"
            },
            {
              "condition": "complex_idea",
              "action": "use_long_sentence"
            }
          ]
        },
        {
          "name": "Avoid Repetition",
          "description": "Do not repeat the same sentence length or structure too often. Ensure each sentence serves a distinct purpose and contributes to the overall flow.",
          "logic": [
            {
              "condition": "repeated_structure_detected",
              "action": "change_sentence_length_and_structure"
            }
          ]
        }
      ]
    }

    Papr_Memory

    This plugin allows the model to access and interact with the user's personal memory graph. It can retrieve information from past conversations, meeting transcripts, documents, and more. Use it when the user's query pertains to information that may be stored in their personal memory.

    • POST /add_memoryAccepts memory item objects with content, type, metadata, context, and relationships_json.
    • POST /get_memoryAccepts search query objects with query, context, and relation_type.
    • PUT /update_memoryUpdate an existing memory item objects with content, type, metadata, context, and relationships_json.
    • DELETE /delete_memoryDelete an existing memory item object using the id.
    Ursprüngliches API-Schema
    {
      "openapi": "3.1.0",
      "info": {
        "title": "Papr_Memory",
        "description": "This plugin allows the model to access and interact with the user's personal memory graph. It can retrieve information from past conversations, meeting transcripts, documents, and more. Use it when the user's query pertains to information that may be stored in their personal memory.",
        "version": "v1"
      },
      "servers": [
        {
          "url": "https://memory.papr.ai"
        }
      ],
      "paths": {
        "/add_memory": {
          "post": {
            "operationId": "add_memory_post",
            "summary": "Accepts memory item objects with content, type, metadata, context, and relationships_json.",
            "security": [
              {
                "OAuth2": [
                  "openid",
                  "profile",
                  "email",
                  "offline_access"
                ]
              }
            ],
            "responses": {
              "200": {
                "description": "Successful Response",
                "content": {
                  "application/json": {
                    "schema": {
                      "$ref": "#/components/schemas/AddMemoryRequest"
                    }
                  }
                }
              },
              "400": {
                "description": "Validation Error",
                "content": {
                  "application/json": {
                    "schema": {
                      "$ref": "#/components/schemas/ValidationError"
                    }
                  }
                }
              }
            },
            "requestBody": {
              "description": "",
              "required": false,
              "content": {
                "application/json": {
                  "schema": {
                    "$ref": "#/components/schemas/AddMemoryRequest"
                  }
                }
              }
            }
          }
        },
        "/get_memory": {
          "post": {
            "operationId": "get_memory_post",
            "summary": "Accepts search query objects with query, context, and relation_type.",
            "security": [
              {
                "OAuth2": [
                  "openid",
                  "profile",
                  "email",
                  "offline_access"
                ]
              }
            ],
            "responses": {
              "200": {
                "description": "Successful Response",
                "content": {
                  "application/json": {
                    "schema": {
                      "$ref": "#/components/schemas/GetMemoryResponse"
                    }
                  }
                }
              },
              "400": {
                "description": "Memory Not Found",
                "content": {
                  "application/json": {
                    "schema": {
                      "$ref": "#/components/schemas/HTTPValidationError"
                    }
                  }
                }
              }
            },
            "requestBody": {
              "description": "",
              "required": true,
              "content": {
                "application/json": {
                  "schema": {
                    "type": "object",
                    "description": "",
                    "properties": {
                      "query": {
                        "type": "string",
                        "description": "Question or query from the user to search an item in memory"
                      },
                      "context": {
                        "type": "array",
                        "description": "",
                        "items": {
                          "type": "object",
                          "description": "",
                          "properties": {
                            "role": {
                              "type": "string",
                              "description": "Person who created the memory item in context ",
                              "enum": [
                                "user",
                                "assistant"
                              ]
                            },
                            "content": {
                              "type": "string",
                              "description": "Content of a memory item or conversation that is related to query "
                            }
                          },
                          "required": [
                            "role",
                            "content"
                          ]
                        }
                      },
                      "relation_type": {
                        "type": "string",
                        "description": "Relationship type given query and context that defines relationship type between memory items you want to find in memory "
                      }
                    },
                    "required": [
                      "query"
                    ]
                  }
                }
              }
            }
          }
        },
        "/update_memory": {
          "put": {
            "operationId": "update_memory_put",
            "summary": "Update an existing memory item objects with content, type, metadata, context, and relationships_json.",
            "security": [
              {
                "OAuth2": [
                  "openid",
                  "profile",
                  "email",
                  "offline_access"
                ]
              }
            ],
            "parameters": [
              {
                "in": "query",
                "name": "id",
                "schema": {
                  "type": "string"
                },
                "required": true,
                "description": "ID of the memory item that needs to be updated"
              }
            ],
            "responses": {
              "200": {
                "description": "Successful Response"
              },
              "400": {
                "description": "Memory Not Found",
                "content": {
                  "application/json": {
                    "schema": {
                      "$ref": "#/components/schemas/ValidationError"
                    }
                  }
                }
              }
            },
            "requestBody": {
              "description": "",
              "required": false,
              "content": {
                "application/json": {
                  "schema": {
                    "$ref": "#/components/schemas/EditMemoryRequest"
                  }
                }
              }
            }
          }
        },
        "/delete_memory": {
          "delete": {
            "operationId": "delete_memory_delete",
            "summary": "Delete an existing memory item object using the id.",
            "security": [
              {
                "OAuth2": [
                  "openid",
                  "profile",
                  "email",
                  "offline_access"
                ]
              }
            ],
            "parameters": [
              {
                "in": "query",
                "name": "id",
                "schema": {
                  "type": "string"
                },
                "required": true,
                "description": "ID of the memory item that needs to be deleted"
              }
            ],
            "responses": {
              "200": {
                "description": "Successful Response"
              },
              "404": {
                "description": "Memory Not Found",
                "content": {
                  "application/json": {
                    "schema": {
                      "$ref": "#/components/schemas/ValidationError"
                    }
                  }
                }
              }
            }
          }
        }
      },
      "components": {
        "securitySchemes": {
          "OAuth2": {
            "type": "oauth2",
            "flows": {
              "authorizationCode": {
                "authorizationUrl": "/login",
                "tokenUrl": "/token",
                "refreshUrl": "/refresh",
                "scopes": {
                  "openid": "OpenID",
                  "profile": "Profile access",
                  "email": "Email access",
                  "offline_access": "Offline access"
                }
              }
            }
          }
        },
        "schemas": {
          "AddMemoryRequest": {
            "type": "object",
            "description": "AddMemoryRequest Schema",
            "properties": {
              "content": {
                "type": "string",
                "description": "The content of the memory item you want to add to memory"
              },
              "type": {
                "type": "string",
                "description": "Content type of the memory item we currently only support text or code_snippet",
                "enum": [
                  "text",
                  "code_snippet"
                ]
              },
              "imageGenerationCategory": {
                "type": "string",
                "description": "Categories of memory items to specify their nature and content. The system will decide to auto-generate images for certain categories based on their relevance for visual representation.",
                "enum": [
                  "narrative_element",
                  "rpg_action",
                  "object_description",
                  "art_idea",
                  "dream_or_fantasy",
                  "historical_event",
                  "personal_memory",
                  "biological_concept",
                  "cultural_reference",
                  "travel",
                  "mood_or_emotion",
                  "web_development",
                  "technical_log",
                  "code_snippet",
                  "error_message",
                  "business_management",
                  "project_management",
                  "document",
                  "instruction",
                  "structured_list",
                  "communication",
                  "medical",
                  "technical_analysis",
                  "resume",
                  "personal_identifiers",
                  "ambiguous_concept",
                  "art_related",
                  "product_idea",
                  "calendar_event",
                  "other"
                ],
                "x-enum-descriptions": [
                  "Visualizing scenes, characters, or events from stories.",
                  "RPG game moves or interactions.",
                  "Descriptions of particular objects, places, or scenes.",
                  "Ideas for art projects, tattoos, room decorations, or clothing designs.",
                  "Dreams or imaginative scenarios.",
                  "Memories referencing historical or fictional events.",
                  "Specific past events or memories.",
                  "Biological organisms, anatomy, or phenomena.",
                  "Cultural or mythological references.",
                  "Memories related to travel experiences or places.",
                  "Abstract feelings or emotions.",
                  "Anything related to web development, including frontend, backend, and databases.",
                  "Logs or technical data.",
                  "Pieces of code or programming-related content.",
                  "Specific error messages or issues.",
                  "Operations, strategies, and details about managing a business.",
                  "Management of projects, tasks, or teams.",
                  "Formal papers, reports, or written content.",
                  "Step-by-step guides or how-tos.",
                  "Bullet-point information or lists.",
                  "General category that can encompass emails, chats, meetings, etc.",
                  "Medical-related memories or information.",
                  "Detailed technical analysis or breakdowns.",
                  "Professional CVs or resumes.",
                  "Personal or sensitive information.",
                  "Concepts that are unclear or not easily defined.",
                  "General category for art-related content.",
                  "Ideas, concepts, or plans related to startups, new products, or business ventures.",
                  "Memories or notes related to scheduling, events, appointments, or reminders to be added to a calendar.",
                  "Any other memory category not listed above."
                ]
              },
              "metadata": {
                "type": "object",
                "description": "Metadata used in Neo4J and Pinecone for a memory item. You can use the properties listed for this metadata and add additional properties as you see fit. ",
                "properties": {
                  "topics": {
                    "type": "string",
                    "description": "List of topics related to the content, context & conversation history "
                  },
                  "hierarchical structures": {
                    "type": "string",
                    "description": "We tend to organize information hierarchically, from broad categories to specific details. Add Hierarchical Structures to enable users to navigate from broad topics to more specific ones."
                  },
                  "createdAt": {
                    "type": "string",
                    "description": "Time of when this memory item was created"
                  },
                  "location": {
                    "type": "string",
                    "description": "Location where the meeting item was captured, could be a meeting room or users physical location"
                  },
                  "emoji tags": {
                    "type": "string",
                    "description": "Emoji tags related to the memory item and conversation history"
                  },
                  "emotion tags": {
                    "type": "string",
                    "description": "Emotion tags related to the memory item and conversation history"
                  },
                  "conversationId": {
                    "type": "string",
                    "description": "Unique identifier for the conversation to which this memory item is related."
                  },
                  "sourceUrl": {
                    "type": "string",
                    "description": "The URL from where the memory item was captured or referenced."
                  }
                }
              },
              "context": {
                "type": "array",
                "description": "Context can be conversation history or any relevant context for a memory item. Don't include the memory item you are already adding in content.",
                "items": {
                  "type": "object",
                  "description": "",
                  "properties": {
                    "role": {
                      "type": "string",
                      "description": "Person who created content for a context list",
                      "enum": [
                        "user",
                        "assistant"
                      ]
                    },
                    "content": {
                      "type": "string",
                      "description": "Content of the previous message that was in conversation history either from user or assistant"
                    }
                  },
                  "required": [
                    "role",
                    "content"
                  ]
                }
              },
              "relationships_json": {
                "type": "array",
                "description": "Array of relationships that we can use in Graph DB (neo4J) that define the relationships between content and context  ",
                "items": {
                  "type": "object",
                  "description": "",
                  "properties": {
                    "related_item_id": {
                      "type": "string",
                      "description": "Relationship that will be used in Graph DB between content and list of context",
                      "enum": [
                        "TextMemoryItem",
                        "previous_memory_item_id"
                      ]
                    },
                    "relation_type": {
                      "type": "string",
                      "description": "The relationship type that defines the neo4j relationship between newly added memory item and the memory item we are creating a relationship with."
                    },
                    "related_item_type": {
                      "type": "string",
                      "description": "Memory item type inside context that you want to relate",
                      "enum": [
                        "TextMemoryItem"
                      ]
                    },
                    "metadata": {
                      "type": "object",
                      "description": "metadata for the relation between content and memory item in context",
                      "properties": {}
                    }
                  },
                  "required": [
                    "related_item_id",
                    "relation_type",
                    "related_item_type",
                    "metadata"
                  ]
                }
              }
            },
            "required": [
              "content",
              "type",
              "metadata",
              "imageGenerationCategory"
            ]
          },
          "HTTPValidationError": {
            "type": "object",
            "description": "HTTP Validation Error",
            "properties": {
              "Detail": {
                "type": "array",
                "description": "",
                "items": {
                  "$ref": "#/components/schemas/ValidationError"
                }
              }
            }
          },
          "ValidationError": {
            "type": "object",
            "properties": {
              "Location": {
                "type": "array",
                "description": "",
                "items": {
                  "type": "string",
                  "description": ""
                }
              },
              "Message": {
                "type": "string",
                "description": ""
              },
              "Error Type": {
                "type": "string",
                "description": ""
              }
            },
            "required": [
              "Location",
              "Message",
              "Error Type"
            ]
          },
          "GetMemoryResponse": {
            "type": "object",
            "properties": {
              "results": {
                "type": "array",
                "description": "",
                "items": {
                  "type": "object",
                  "description": "",
                  "properties": {}
                }
              }
            },
            "required": [
              "results"
            ]
          },
          "EditMemoryRequest": {
            "type": "object",
            "description": "EditMemoryRequest",
            "properties": {
              "content": {
                "type": "string",
                "description": "New content for the memory item, this will replace existing content for this memory item"
              },
              "metadata": {
                "type": "object",
                "description": "Metadata used in Neo4J and Pinecone for a memory item. You can use the properties listed for this metadata and add additional properties as you see fit. ",
                "properties": {
                  "topics": {
                    "type": "string",
                    "description": "List of topics related to the content, context & conversation history "
                  },
                  "hierarchical structures": {
                    "type": "string",
                    "description": "We tend to organize information hierarchically, from broad categories to specific details. Add Hierarchical Structures to enable users to navigate from broad topics to more specific ones."
                  },
                  "updatedAt": {
                    "type": "string",
                    "description": "Time of when this memory item was updated"
                  },
                  "location": {
                    "type": "string",
                    "description": "Location where the meeting item was captured, could be a meeting room or users physical location"
                  },
                  "emoji tags": {
                    "type": "string",
                    "description": "Emoji tags related to the memory item and conversation history"
                  },
                  "emotion tags": {
                    "type": "string",
                    "description": "Emotion tags related to the memory item and conversation history"
                  }
                },
                "required": [
                  "updatedAt"
                ]
              }
            },
            "required": [
              "content"
            ]
          }
        }
      }
    }