book.3_project.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a full project\n",
    "\n",
    "## Example: Image Scribe\n",
    "\n",
    "In our example, we will create a python pipeline for extracting images from pdfs, transcribing them to text using OCR, and storing that in a database. This application is particularly for PDFs that store content as images, such as scans of books or receipts.\n",
    "\n",
    "### Building in stages\n",
    "\n",
    "We are going to create a whole project using SimpleCoder and this Jupyter notebook. We are going to create multiple files which are going to be interdependant and must have consistent use of classes, function signatures, etc.\n",
    "\n",
    "To do this, we are going to direct SimpleCoder to build out the project in several stages. Each stage will take input from the previous stages and add new details and features. \n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from moleculai import SimpleCoder\n",
    "\n",
    "C_WORKING_DIR = \"~/Documents/projects/image-scribe\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use the git, young Padawan\n",
    "\n",
    "Git will make it super easy for us to review the code that SimpleCoder generates at each stage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cd {C_WORKING_DIR}\n",
    "!git init"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 1: about.md\n",
    "\n",
    "### Create a project plan\n",
    "\n",
    "This is our first step and the key here is to create some more information about your project from a brief description.\n",
    "\n",
    "We will then use this about.md file as a backdrop for most of our other commands, to give our agent the proper context for task execution.\n",
    "\n",
    "### \"Prompt Engineering\" - how to use words good\n",
    "\n",
    "This portion of the instruction is actually key: **for a developer to implement**\n",
    "\n",
    "It creates a very sepcific perspective and goal for the LLM to follow in writing this up, particularly that a developer will read this and will need certain information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Breaking these two parts out for clarity:\n",
    "\n",
    "project_description=\"I need to build a python pipeline to process all PDFs in a directory, extract all pages from the pdf as images, then do ocr on all the images to find text, and then save the text to a mongodb database.\"\n",
    "\n",
    "task_instruction=\"Write a description of the pipeline for a developer to implement. Use markdown, diagrams, text, or whatever you need to communicate the pipeline.\"\n",
    "\n",
    "agenda = {\n",
    "    \"requirements\": project_description + task_instruction,\n",
    "    \"output_file_name\": \"about.md\",\n",
    "    \"working_dir\": C_WORKING_DIR\n",
    "}\n",
    "\n",
    "# Create and run the agent\n",
    "coder = SimpleCoder(**agenda)\n",
    "print( await coder.run() )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read before you do the deed\n",
    "\n",
    "General rule of thumb: Don't blindly trust AI output.\n",
    "\n",
    "Let's take a look at this output before we start creating files. If we want, we can edit our instructions and try again.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cat {C_WORKING_DIR}/\"about.md\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 2: files.md\n",
    "\n",
    "### Create list of project resources"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "agenda = {\n",
    "    \"requirements\": \"You are a project manager. Read the file about.md and create a list of files that need to be created by a developer, in chronological order.\",\n",
    "    \"output_file_name\": \"files.md\",\n",
    "    \"input_file_list\": [\"about.md\"],\n",
    "    \"working_dir\": C_WORKING_DIR,\n",
    "    \"force_code\": False\n",
    "}\n",
    "\n",
    "# Create a coder agent using the agenda\n",
    "coder = SimpleCoder(**agenda)\n",
    "\n",
    "# Run the agent\n",
    "await coder.run()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Review\n",
    "\n",
    "Check the list of files we are going to be creating and remove anything extra like placeholders."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cat {C_WORKING_DIR}/\"files.md\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 3: file_details.json\n",
    "\n",
    "### Feed forward loop\n",
    "\n",
    "An important aspect of our construction mechanism is to include previous outputs in our new request. \n",
    "\n",
    "Note the use of `input_file_list` for this purpose.\n",
    "\n",
    "The meta data we are creating in this step will be used in the same way in the following steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "agenda = {\n",
    "    \"requirements\": \"\"\"\n",
    "    Read the file about.md file with the project description, then the files.md with the list of files will need, and create a file with a detailed description of each file that needs to be created.\n",
    "    Include all necessary function signatures and docstrings in the description.\n",
    "    List them in the order in which they need to be created, with the dependencies first.\n",
    "    Use json fomrat like this {\"files\":[{\"name\":\"filename.ext\",\"description\":\"description of file\"}]}.\"\"\",\n",
    "    \"output_file_name\": \"files_details.json\",\n",
    "    \"input_file_list\": [\"about.md\", \"files.md\"],\n",
    "    \"working_dir\": C_WORKING_DIR,\n",
    "    \"force_code\": False\n",
    "}\n",
    "\n",
    "# Create a coder agent using the agenda\n",
    "coder = SimpleCoder(**agenda)\n",
    "\n",
    "# Run the agent\n",
    "await coder.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cat {C_WORKING_DIR}/files_details.json"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 4: Create All Project Files\n",
    "\n",
    "We are going to add some extra `voodoo` here to iterate over the list of files we created befofre, and execute SimpleCoder for each one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# read the json file\n",
    "import json\n",
    "import os\n",
    "\n",
    "file_path = os.path.expanduser(os.path.join(C_WORKING_DIR,\"files_details.json\"))\n",
    "\n",
    "with open(file_path, \"r\") as f:\n",
    "    data = json.load(f)\n",
    "\n",
    "if not('files' in data and data['files']):\n",
    "    raise Exception(\"Could not read files from json file\")\n",
    "\n",
    "# Make sure to include our project description\n",
    "file_names_all=[\"about.md\"]\n",
    "\n",
    "# for each file instance, create a file with the name and description\n",
    "for file in data['files']:\n",
    "    print(f\"working on file: {file['name']}\")\n",
    "    description = json.dumps(file, indent=4)\n",
    "\n",
    "    agenda = {\n",
    "        \"requirements\": f\"{description}\",\n",
    "        \"output_file_name\": file['name'],\n",
    "        \"input_file_list\": file_names_all,\n",
    "        \"working_dir\": C_WORKING_DIR,\n",
    "        \"force_code\": True\n",
    "    }\n",
    "\n",
    "    # Create a coder agent using the agenda\n",
    "    coder = SimpleCoder(**agenda)\n",
    "\n",
    "    # Run the agent\n",
    "    await coder.run()\n",
    "\n",
    "    # Add the file to our list for the next input stage\n",
    "    file_names_all.append(file['name'])\n",
    "\n",
    "print (\"DONE\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 5: Iterating and Refactoring\n",
    "\n",
    "It is inevitable that the output code will require either fixes, changes in function, or new features. Refactoring with an LLM can make it super simple to make a lot of changes very quickly.\n",
    "\n",
    "### Save that brain energy for the hard stuff!\n",
    "\n",
    "We can use a refactoring routine as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "agenda = {\n",
    "    \"requirements\": f\"Refactor this file to accept all paths as parameters.\",\n",
    "    \"output_file_name\": \"ocr.py\",\n",
    "    \"working_dir\": C_WORKING_DIR,\n",
    "    \"force_code\": True\n",
    "}\n",
    "\n",
    "# Create a coder agent using the agenda\n",
    "coder = SimpleCoder(**agenda)\n",
    "\n",
    "# Run the agent\n",
    "await coder.run()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}