FountainAI Repository

Welcome to the FountainAI project repository! This document serves as the central guide for understanding the project's vision, architecture, and implementation plan. Whether you're a new contributor or familiarizing yourself with the project, this README provides the necessary information to get started.

Table of Contents

1. Introduction
2. Project Overview
3. Repository Structure
4. Implementation Plan
5. Development Standards
   • Workbook Format
   • Visualization Standards
   • Shell Scripting Guidelines
   • Security Practices
6. Getting Started
7. Contributing
8. Additional Resources
9. Contact and Support
10. License

Introduction

FountainAI is an advanced project aimed at revolutionizing narrative development through a microservices architecture that automates storytelling processes such as sequence management, character management, and session context orchestration. The core technologies include OpenAI's GPT-4, FastAPI, Docker, and AWS infrastructure. The primary goal is to create a modular, scalable, and secure system that helps manage dynamic narratives with efficiency.

Project Overview

The repository is structured to support the development, deployment, and maintenance of FountainAI services through:

• Microservices Architecture: Modular services that interact to provide narrative functionalities.
• OpenAPI Specifications: Centralized OpenAPI definitions for all services, enabling consistent API generation and validation.
• Workbooks: Step-by-step guides to generate, modify, and deploy components of FountainAI.

Current Development Focus

The current development focus is on automating code generation using OpenAPI definitions, following the FountainAI workbook format for consistency and scalability. The system heavily relies on GPT-4 and shell scripting to facilitate this process. We are transitioning from earlier general guidance documents to a more focused, action-driven workbook format, meaning some older documentation is now marked as deprecated.

Repository Structure

.
├── Guidance
│   ├── Part A_ Introduction and Architecture Overview.md             # Deprecated
│   ├── Part B_ GPT Code Generation Sessions.md                       # Deprecated
│   ├── Part C_ Deployment, CI_CD Enhancements, and Custom Logging.md # Deprecated
├── Project Report by Date
│   └── FountainAI Project Report.md                                  # Current project reports
├── README.md                                                         # This file
├── Use Cases
│   └── The Role of Context in FountainAI.md                          # Deprecated
├── Workbooks
│   ├── FountainAI Code Generation Workbook.md                        # Active: Central resource for developing FountainAI
│   ├── FountainAI Visualization Standards.md                         # Active: Standards for visual representations
│   └── README.md                                                     # Active: Workbook structure and norms
├── create_new_main_branch.sh                                         # Shell script to manage branches
└── openAPI
    ├── API-Docs-GPT-4o-Paraphrase
    │   ├── API Documentation - Central Sequence Service API Documentation.md # OpenAPI docs paraphrased via GPT-4
    │   ├── API Documentation - Character Management API.md                  # OpenAPI docs paraphrased via GPT-4
    │   ├── API Documentation - Core Script Management.md                    # OpenAPI docs paraphrased via GPT-4
    │   ├── API Documentation - Session and Context Management API.md        # OpenAPI docs paraphrased via GPT-4
    │   └── API Documentation - Story Factory API.md                         # OpenAPI docs paraphrased via GPT-4
    ├── central-sequence-service.yaml                                        # Active: OpenAPI YAML for Central Sequence Service
    ├── character-management.yaml                                            # Active: OpenAPI YAML for Character Management
    ├── core-script-management.yaml                                          # Active: OpenAPI YAML for Core Script Management
    ├── o1-preview-FountainAI-system-description
    │   ├── Appendix
    │   │   └── Appendix_ FountainAI Implementation Path Documentation.md    # Extended Implementation Path
    │   ├── Comprehensive FountainAI Implementation Guide (Extended).md      # Deprecated: Replaced by Workbook Format
    │   ├── Comprehensive FountainAI Implementation Guide.md                 # Deprecated: Replaced by Workbook Format
    │   ├── Requirements Engineering
    │   │   ├── Deprecated - FountainAI System Description.md                # Deprecated
    │   │   ├── FastAPI Implementation Path for the Official FountainAI System.md # Deprecated
    │   │   ├── Official FountainAI Implementation Requirements_ Ensuring Compliance with OpenAPI Specifications.md # Deprecated
    │   │   └── Official FountainAI System Description and Implementation Plan.md # Deprecated
    │   ├── Step -1-Implementation of the Central Sequence Service API
    │   │   ├── Continuing the Implementation of the Central Sequence Service API.md # Active: Implementation guide
    │   │   └── Official FountainAI System Implementation_ Central Sequence Service API.md # Active: Implementation guide
    │   ├── Step-2-Character Management API
    │   │   └── Official FountainAI Implementation Path_ Character Management API.md # Active
    │   ├── Step-3-Core Script Managment API
    │   │   └── Official FountainAI Implementation Path_ Core Script Management API.md # Active
    │   ├── Step-4-Session and Context Management API
    │   │   └── Official FountainAI Implementation Path_ Session and Context Management API.md # Active
    │   └── Step-5-Story Factory API
    │       ├── Appendix_ From Mock to Real Implementation of the FountainAI Story Factory Service.md # Active
    │       └── Official FountainAI Implementation Path_ Story Factory API.md # Active
    ├── session-and-context.yaml                                            # Active: OpenAPI YAML for Session and Context Management
    └── story-factory.yaml                                                  # Active: OpenAPI YAML for Story Factory

Deprecation Notices

• The Guidance documents (Part A, Part B, and Part C) are now marked as deprecated in favor of the workbook-driven approach. These files remain for historical context but should not be referenced for current development.
• Use Cases have shifted away from abstract discussions (previously covered in "The Role of Context in FountainAI.md") and are now embedded into workbook-driven examples for each service.

Implementation Plan

The implementation of FountainAI revolves around OpenAPI-driven code generation and workbook-guided service development. The key steps include:

1. Define Service Specifications

• Use OpenAPI to document the APIs for services such as the Central Sequence Service, Character Management, and others.
• YAML files are stored in the openAPI directory and serve as the foundation for automated code generation.

2. Code Generation via Workbooks

• The FountainAI Code Generation Workbook guides developers on interacting with OpenAI GPT-4 to generate FastAPI service code from OpenAPI definitions.
• Each service has a specific workbook that provides structured steps to follow, including shell scripts for code generation and modification.

3. Modify and Standardize Code

• Adhere to FountainAI coding norms by modifying generated code using the provided workbooks and shell scripts.
• Ensure consistency in formatting, logging, and environment management.

4. Deployment and Security

• Services are deployed using Docker containers on AWS infrastructure (ECS/Fargate).
• Use AWS CloudFormation and CI/CD pipelines for automated deployments.
• Implement HTTPS across all stages using AWS Certificate Manager (ACM).

Development Standards

The FountainAI Workbook Format is central to development, ensuring consistency and scalability across all services.

Workbook Format

• Introduction: Overview of the service or task.
• Prerequisites: Tools, libraries, and access needed.
• Step-by-Step Instructions: Detailed walkthrough of tasks, including code snippets and shell scripts.
• Shell Scripting: Idempotent shell scripts following the FountainAI norms, provided for automating various tasks.
• Visualization: ASCII diagrams first, followed by Graphviz or pre-rendered images for more complex visualizations.

Visualization Standards

• ASCII Diagrams are the primary visualization tool for simplicity.
• Use Graphviz DOT language for more complex diagrams.
• Store both source and rendered diagrams for version control in the Diagrams directory (to be added).

Shell Scripting Guidelines

• Modular and Idempotent: Shell scripts must be reusable and safe to run multiple times.
• Scripts generate code, configure environments, and manage deployments.

Security Practices

• HTTPS Everywhere: Ensure HTTPS is enforced using SSL/TLS certificates provided by AWS Certificate Manager.
• Environment Configuration: Use environment variables to manage sensitive information securely.
• Secret Management: Employ AWS Secrets Manager where necessary.

Getting Started

1. Clone the Repository:

   git clone https://github.com/Contexter/FountainAI.git

2. Review the Workbooks: Start with the FountainAI Code Generation Workbook in the Workbooks directory.

3. Set Up Development Environment: Install required tools and dependencies as outlined in the workbooks.

4. Generate Code: Use the workbooks to interact with GPT-4 for generating service code based on the OpenAPI specs.

5. Deploy Services: Follow the deployment guidelines for containerizing and deploying services to AWS.

Contributing

1. Fork the Repository.
2. Create a New Branch for your feature or bugfix.
3. Make Your Changes following the workbook format.
4. Submit a Pull Request with a detailed explanation of your changes.

Additional Resources

• FountainAI Workbook Guide: Workbooks/README.md
• AWS Documentation:
  • AWS CLI
  • AWS CloudFormation
  • AWS ECS
• OpenAI API Documentation: OpenAI API Reference
• FastAPI Documentation: FastAPI
• Docker Documentation: Docker Docs

Contact and Support

For questions or support:

• GitHub Issues: Submit an Issue
• Email: mail@benedikt-eickhoff.de

License

This project is licensed under the MIT License. See the LICENSE file for more details.

Happy Coding!

Note: This README provides a comprehensive overview of the FountainAI project, incorporating its current development focus and transitioning from deprecated guidance to workbook-centric development.