DEV Community: octopus inc

Create agentic systems by just describing what you want.

octopus inc — Sun, 10 Nov 2024 18:45:38 +0000

Introduction

Agentic AI is a growing trend among developers and companies wanting to get the most out of intelligent machines. There is a growing list of impacful use cases, from marketing automation to customer support and beyond.

However, building agentic systems today is still a cumbersome process, even for seasoned AI engineers. Most frameworks, like langchain, crewAI introduce unnecessary abstrations that make debugging difficult. In fact, many people prefer to write their code from scratch after a few frustated attempts.

But can LLMs themselves help to write code for agentic systems, and hence reduce the pain of development? In principle yes, like any other code. But current frameworks are not optimized for that: because they are excessively verbose, the LLM spends an unnecessary amount of tokens and brainpower generating classes, calling methods, which are needed for the framework itself, while beign unrelated to the workflow logic.

GenSphere: a programming language designed for LLMs to use while coding

GenSphere is an open-source, python-based project that enables developers to define AI workflows using simple YAML files, outlining the tasks and their connections without delving into the procedural complexities. Each node in the workflow represents a high-level operation — be it a function call, an LLM API request, or another nested workflow. By abstracting the execution logic, GenSphere lets you focus on orchestrating sophisticated AI applications declaratively.

Because the YAML files are an economical description of workflow logic, which abstract away the execution code, one can use LLMs themselves to generate those files from high-level prompts. The LLM will spend their output tokens and brainpower fully on implementing the workflow logic instead of writing code. This opens the possibility of building full-fledged text-to-agents workflows.

How GenSphere works

On GenSphere, you build LLM applications with YAML files, that define an execution graph. Nodes can be either LLM API calls, regular function executions or other graphs themselves.

Because you can nest graphs easily, building complex applications is not an issue, but at the same time you don’t lose control. The YAML basically states what are the tasks that need to be done and how they connect. Other than that, you only write individual python functions to be called during the execution. No new classes and abstractions to learn.

Generate agentic systems by prompting

As GenSphere projects are defined by simple YAML files (and their associated functions and schemas) one can use LLMs themselves to generate those files.

This Google Colab example shows how to use a GenSphere project from the public Hub to take a task.txt file as input and output another GenSphere project that accomplishes that task. You can then run that GenSphere project to get your final output.

The example in the notebook uses the following task as input:

Your task is to generate script for 10 YouTube videos, about 5 minutes long each.
Our aim is to generate content for YouTube in an ethical way, while also ensuring we will go viral.
You should discover which are the topics with the highest chance of going viral today by searching the web.
Divide this search into multiple granular steps to get the best out of it. You can use Tavily and Firecrawl_scrape
to search the web and scrape URL contents, respectively. Then you should think about how to present these topics in order to make the video go viral.
Your script should contain detailed text (which will be passed to a text-to-speech model for voiceover),
as well as visual elements which will be passed to as prompts to image AI models like MidJourney.
You have full autonomy to create highly viral videos following the guidelines above. 
Be creative and make sure you have a winning strategy.

It outputs a full workflow with 12 nodes, multiple rounds of searching and scraping the web, LLM API calls, (attaching tools and using structured outputs autonomously in some of the nodes) and function calls.

Learn more about GenSphere

GitHub Repository: Explore the code and contribute.
Documentation: Dive deeper into the GenSphere Documentation.
Tutorial: Follow the tutorial Google Colab notebook to get hands-on experience.
Prompt-to-agent example: Follow this Google Colab notebook
Community: Connect with other developers on the Discord Server.

Community-driven development of LLM applications — introducing GenSphere

octopus inc — Wed, 06 Nov 2024 21:14:50 +0000

Introduction

In the rapidly evolving world of artificial intelligence, Large Language Models (LLMs) have unlocked unprecedented possibilities. However, building complex LLM applications remains a daunting task, riddled with unnecessary abstractions and steep learning curves. Enter GenSphere — a declarative framework that’s set to redefine how we develop, share, and scale AI applications.

How genAI-based applications are built today — and what is missing

In recent years, we’ve witnessed impressive use cases of Generative AI (GenAI) and Large Language Models (LLMs) delivering tangible value across various domains. From virtual assistants that understand natural language to AI systems that automate complex tasks requiring common sense reasoning and processing unstructured data, the potential is enormous.

However, despite these advancements, most GenAI applications today are built as monoliths — end-to-end systems developed in isolation. There is minimal reuse of components across the community. This lack of collaboration stems from several challenges:

Fragmented Ecosystem: Different frameworks are written in various programming languages, making integration difficult. For instance, combining a Python-based NLP module with a Java-based data processing tool requires significant effort.
Lack of Community-First Approach: Existing frameworks weren’t designed with collaboration in mind. They don’t optimize for easy combination of systems, leading to siloed development.
Complexity of Integration: Even when components are available, the absence of standardized interfaces and protocols makes it hard to plug them into new applications seamlessly.

The Missing Piece: Collaborative, Modular Development

Imagine a world where building GenAI applications is akin to assembling Lego blocks — each piece optimized, reusable, and designed to fit perfectly with others. This is where the potential of GenSphere truly shines.

Accelerating Development Through Reusability:

Let’s consider the process of automating a content creation platform using AI. Traditionally, you’d need to develop:

Data Extraction Pipelines: Scraping and gathering information from various sources.
Content Generation Modules: Using LLMs to create articles, videos, or social media posts.
Visual Enhancement Tools: Adding images, graphics, or interactive elements.
SEO Optimization Processes: Ensuring the content ranks well on search engines.

Developing each component from scratch is time-consuming and inefficient.

But what if you could:

Leverage a Community of Optimized Building Blocks:

Access modules crafted and refined by experts.
Utilize pre-built workflows for data extraction, content generation, and SEO optimization.
Benefit from continuous improvements as the community enhances these components.

Use a Framework That Simplifies Integration:

Imagine having a declarative approach to assemble these blocks effortlessly.

Contribute Back to the Ecosystem:

Imagine being able to trigger a positive feedback loop, where every element from a platform of reusable blocks is using to create new blocks, which are then fed back to the platform. This would make the process of community-driven development progressively better and more powerful.

GenSphere, a declarative framework for LLM applications

What is a declarative framework?

At its core, a declarative framework allows developers to specify what the program should accomplish without dictating how to achieve it. This contrasts with imperative programming, where the focus is on explicit instructions. Declarative frameworks emphasize the desired outcome, leaving the execution details to the underlying system.

Having a declarative paradigm at its root allows GenSphere to tackle the challenges described before, by making the process of combining, sharing and building LLM applications much easier, all at the same time.

How GenSphere works

On GenSphere, you build LLM applications with YAML files, that define an execution graph. Nodes can be either LLM API calls, regular function executions or other graphs themselves.

By providing a standardized, declarative way to build and share AI applications, GenSphere:

Eliminates Unnecessary Abstractions: Gain low-level control without the overhead of convoluted frameworks.
Enhances Portability: Share and deploy AI workflows effortlessly across different environments.
Fosters Community Growth: Leverage the collective intelligence of developers worldwide by sharing and reusing workflows.

New possibilities unlocked by GenSphere

GenSphere’s ability to nest workflows means you can build specialized agents for specific tasks and then combine them to tackle more complex challenges. This modularity is a game-changer, specially when community collaboration drives further enhancement and specialization of modules.

Example 1: Automated Financial Analysis

Components:

Data Scraper Workflow: Extracts financial data from enterprise reports.
Data Structuring Workflow: Organizes raw data into structured formats.
RAG Workflow: Retrieves relevant information as needed.
Combined Application: An automated stock trading agent that analyzes market trends and executes trades based on real-time data.

Example 2: Intelligent Content Creation

Components:

Keyword Research Workflow: Uses LLMs to identify trending topics.
Content Generator Workflow: Produces high-quality articles.
SEO Optimizer Workflow: Enhances content for search engine visibility.
Combined Application: A content creation engine that generates SEO-optimized blog posts tailored to current trends.

Example 3: Personalized Education Platforms

Components:

Curriculum Designer Workflow: Creates personalized learning paths.
Assessment Generator Workflow: Develops custom quizzes and tests.
Feedback Analyzer Workflow: Uses LLMs to interpret student performance.
Combined Application: An adaptive learning system that personalizes education at scale.

Example 4: Advanced Customer Support Bots

Components:

Intent Recognition Workflow: Understands customer queries.
Knowledge Base Access Workflow: Retrieves solutions from documentation.
Response Generator Workflow: Crafts coherent and helpful replies.
Combined Application: An intelligent support bot that provides instant, accurate assistance to customers.

Community-Driven Development

By pushing your workflows to the GenSphere hub, you contribute to a growing repository of AI capabilities. This collective resource accelerates innovation, as developers can:

Reuse and Remix: Combine existing workflows to create new applications.
Collaborate Globally: Work alongside a community passionate about advancing AI.
Gain Recognition: Track the popularity of your workflows through pull counts.

As an ambitious open-source movement, GenSphere aims to create foundational AI-agents and applications that can be reused across many different use cases. Leveraging community collaboration will allow achieving what no other team could do alone. If you would like to join this movement, reach out at the GitHub repo and Discord server.

Quick Start Example: Building with GenSphere

Step 1: Installation
Install GenSphere using pip:

pip install gensphere

Step 2: Import Modules and Set API Key

from gensphere.genflow import GenFlow
from gensphere.hub import Hub
import os

os.environ['OPENAI_API_KEY'] = "YOUR_OPENAI_API_KEY"
Step 3: Pull an Existing Workflow from the GenSphere Hub

hub = Hub()
hub.pull(
    push_id='2c03079c-0e33-489e-bbbe-777da744d56f',
    yaml_filename='simple_examples.yaml',
    functions_filename='simple_examples_functions.py',
    save_to_disk=True
)

Step 4: Execute the Workflow

flow = GenFlow('simple_examples.yaml', 'simple_examples_functions.py')
flow.parse_yaml()
flow.run()

Step 5: Access Outputs

print(flow.outputs)

Step 6: Visualize Your Workflow

from gensphere.visualizer import Visualizer

viz = Visualizer('simple_examples.yaml', 'simple_examples_functions.py')
viz.start_visualization()

Get Started Today

Ready to join ? Here are your next steps:

GitHub Repository: Explore the code and contribute at github.com/octopus2023-inc/gensphere.
Documentation: Dive deeper with the GenSphere Documentation.
Tutorial: Follow the 5-Minute Tutorial Notebook to get hands-on experience.
Community: Connect with other developers on our Discord Server.