AI for Enterprise Applications

Build AI-powered applications that connect securely to your enterprise data and APIs. Maintain control and flexibility at every step.

What is Griptape?

"It's the Python I'm used to!"

Griptape provides an open-source Python framework and a managed cloud platform for building and deploying enterprise-class AI applications. You can easily create simple LLM-powered agents, compose sequential event-driven pipelines, or orchestrate complex DAG-based workflows.

Build AI Apps

Easily compose apps in Python with modular structures and ready-made tools. Use built-in drivers to connect to your preferred LLMs and data stores.

Control Data Access

Connect securely to data sources with granular access controls, ensuring LLMs stay focused on the information that matters.

Scale With Your Workload

Easily deploy and run apps in the cloud, where your data resides. Process data ahead of time or vectorize it on the fly.

Using Griptape, you can securely integrate with your internal data stores and APIs. You have control over the data that goes into the prompt and what the LLM is allowed to do with it.

Chat with an Agent

Griptape Agents provide incredible power and flexibility when working with large language models. Add a couple of tools, a bit of personality, and away you go.

They use Chain-of-Thought reasoning and have Short-Term Memory to determine the right thing to do with the capabilities they are given.
# Create a Griptape Agent and give it a WebScraper tool
# Use the Chat utility to chat with it.

from griptape.structures import Agent
from import WebScraper
from griptape.utils import Chat

# Create the agent and give it a WebScraper tool
agent = Agent( 
    tools=[ WebScraper(off_prompt=False) ]

# Chat with the agent
Tell me about


Find info about
Use WebScraper tool
Stored output in Memory.
Summarize the content.
Use TextToolMemory to summarize.
A: is an open source framework for building and deploying AI applications using large language models.

Create a Pipeline

Griptape Pipelines are ideal for prescriptive processes that need to be executed sequentially. They string together multiple tasks of varying types, and can use Short-Term Memory or pass specific arguments downstream.
# Create a Griptape Pipeline that executes a series of tasks.
#   1. Use a ToolkitTask to scrape the web for information
#   2. Use a PromptTask to create bullet points from the results
#   3. Use a ToolTask to save the results to griptape.txt

from griptape.structures import Pipeline
from griptape.tasks import ToolkitTask, PromptTask, ToolTask
from import WebScraper, FileManager

# Create a pipeline
pipe = Pipeline()

# Add some tasks
    "What does do?", 
    tools=[ WebScraper(off_prompt=False) ]

    "Create bullet points for executive overview {{ parent_output }}"

    "Save the following to griptape.txt: {{ parent_output }}", 

# run the pipeline

Create a Workflow

Griptape Workflows are non-sequential DAGs that can be used for complex concurrent scenarios with tasks having multiple inputs.
# Creates a Griptape Workflow that takes three rough movie descriptions.
# For each movie description:
#   1. Use a PromptTask to get the name of the movie
#   2. Use a ToolkitTask to scrape the web for a better description
#   3. Use a TextSummaryTask to summarize the description
# When all tasks are finished:
# Use a PromptTask to get the similarities of the movie.

from griptape.structures import Workflow
from griptape.tasks import ToolkitTask, PromptTask, TextSummaryTask
from import WebScraper, FileManager

# Create a Workflow
workflow = Workflow()

# Create a list of movie descriptions
movies = [
    "A kid discovers an alien in his backyard in the 80s",
    "A movie about a kid who gets big.",
    "A black and white movie that turns to color, with a tornado."

# Create a start task
start_task = PromptTask("We are going to compare some movies")

# Create a comparison task
compare_task = PromptTask(
    Explain the similarities about these movies:
    {% for key, value in parent_outputs.items() %}
    {{ value }}
    {% endfor %}

# Add the Start and End tasks

# Create a set of tasks for each movie
for movie in movies:
    # Create the tasks
    name_task = PromptTask(
        f"What is the name of the movie described: { movie }"
    describe_task = ToolkitTask(
        Get a short description of the movie:
        {{ parent_outputs.values()|list|first }}
    tools=[ WebScraper(off_prompt=False) ]

    summarize_task = TextSummaryTask(
        "{{ parent_outputs.values()|list|first }} "

    # Insert them into to the workflow

    workflow.insert_tasks(start_task, [name_task], compare_task)
    workflow.insert_tasks(name_task, [describe_task], compare_task)
    workflow.insert_tasks(describe_task, [summarize_task], compare_task)

# Run the workflow

Griptape Cloud

Private Preview

Griptape Cloud is a managed platform for running AI agents, pipelines, and workflows. It makes it easy to deploy, manage, schedule, and connect AI apps to your data stores and APIs.

Hear from Our Customers

Griptape helps us keep LLMs on task. Now we can reliably get fast and precise results out of long-running, multi-step AI-driven business processes without the tiresome trial-and-error of prompt engineering."
Rapidly bringing developers up to speed on new technologies is what we do best at Torc. That’s why companies partner with us to hire top talent, and it’s why we use Griptape to accelerate AI and LLM skills across our dev community."
The modularity and flexibility of Griptape enables our consultants to deliver the right technology solution for each client’s use case and data sources. Regardless of which LLM, cloud provider, and data governance the solution requires, we know we can build it with Griptape."

Griptape Is Backed By

Not Sure How to Start?

Working with large language models is new and exciting, but can also be overwhelming. How do you integrate? What technique should you use? How do you even approach starting?

Contact us to discuss Griptape