I have found the growth of artificial intelligence to be interesting. A while back I read Mark Zuckerberg's blog post on his AI. This got me thinking, what if I were to create an AI system for development purposes. I have various tasks that already run on cron jobs or that I manually run, but for the most part I need access to one of my Raspberry Pi's for those tasks. Also, sometimes it is just inconvenient to manually do these tasks while I am working on something else. This brings me to the beginning of a new project I am going to be starting soon and will be posting on Github as it gets going.

Plans

I plan to build an extensible framework for a personal AI to allow me to more efficiently do some of my common tasks. The hope in building this is that all tasks could be created as plugins that could be put into place at any point. I will be naming the system EDDA (Extensible Daily Development Assistant) to mirror the intentions of the project as a whole.

The first task that I will be incorporating into the framework will be working with backups. I currently back up critical files on some of the servers I work on, including my web server. When I am working on something that isn't using git it is nice to have these backups of my projects. These backups are then stored using a Raspberry Pi and a USB connected hard drive. Once the backups are made, it would be good to have the ability to retrieve them wherever I am. So the second part of the backup system will be to have the ability to have either a full backup or a specific file from a date emailed or otherwise sent to me.

Backups are one of the primary tasks I see the AI doing immediately. I am also hoping to have EDDA be able to send WOL packets to start computers so that I can remote into them and also automatically check the status of servers or systems and report them to me.

Past development tasks, there are a couple of general tasks that EDDA could potentially be created to handle such as looking at a calendar, adding or removing tasks from my todo lists, or watching for specific weather conditions. Of course, if the base of the system is designed properly to be extensible other tasks could be added.

Implementation

The current plan for implementation is to create this using Java to take advantage of some of the frameworks that exist. The current frameworks I am looking into for creating the core of EDDA are Apache Jena and Apache OpenNLP. For input, the project will start with either a simple GUI or a command line interface and move to using a communication platform such as Telegram to allow communication from wherever I may be.

Due to the fact that EDDA should be extensible and will be on Github to be worked on and hopefully used by others eventually, many of the core configurations will be separated outside of the code to reduce the amount of recompiling or code changes that may be required for new users. This also will help keep private information outside of the codebase.

Due to the nature of the project, I am not yet sure what the system requirements will be. The hope will be to have this run on a Raspberry Pi efficiently enough to be usable. The motivator for this is that they are cheap and make good small servers, especially on a college budget.

Core Sections

I am currently planning on five major sections of the project.

  1. The I/O system. This will of course be in charge of getting input from the user and giving feedback to them throughout the usage of EDDA.
  2. The NLP system. Since spoken and written language can be fuzzy, natural language processing will definitely be required. For this I will be taking the input through Apache NLP. In addition the language should take the person using EDDA into account.
  3. The main processor. The main processor will be the most complex section. After the input is parsed by the NLP system, the correct action needs to be chosen. From here we will call upon the plugin framework, make the decisions, and pass it to the action handler.
  4. The plugin framework. The whole system is reliant on the idea of quickly being able to add new functionality through plugins. The plugin framework will standardize an API for these plugins.  In addition it will report back to the processor what plugins are available, which ones match the request.
  5. The action handler. Once the main processor has figured out what to do, then the action needs to be taken. This section should be simple since all of the decisions should be handled before this. The action handler would then take the needed action and hand the result back to the output system.

Conclusion

I will be taking an AI course this fall, but do not have any direct experience with creating an AI yet. Due to this, the creation of EDDA could be rocky at certain points. The benefit of this is that it should help provide an interesting learning experience. This is definitely not going to be a general project like Zuckerberg's Jarvis or the leading AI projects from Google, Amazon, or Apple, but hopefully it will be useful system for my daily use.

Feedback?

What are your thoughts on this project? What else should EDDA be able to do? Did I miss considering something important?