Forem: Griptape AI

What the Heck Are Hybrid Knowledge Bases? (And Why They Matter for LLM Apps)

Kirk Crenshaw — Fri, 25 Apr 2025 17:51:56 +0000

If you're building with LLMs and trying to give your agents or copilots real context, you've probably used a vector database.

They're great for unstructured data — PDFs, HTML, markdown, text blobs. But what happens when your data isn't just text?

Enter Hybrid Knowledge Bases.

Now available in Griptape Cloud, they let you store and retrieve structured and unstructured data — together — and query them intelligently in your apps.

🧠 So... What Is a Hybrid Knowledge Base?

A Hybrid Knowledge Base compliments a vector store by combining:

🔢 Structured data: things like location, job titles, timestamps, metadata fields
📝 Unstructured data: resumé text, emails, notes, paragraphs, docs

You can use natural language queries or programmatic ones — and get results that combine exact-match filters with vector similarity searches.

🛠️ Example Use Case: Candidate Search

You're building a recruiter assistant. You have:

Structured data: candidate name, location, years of experience
Unstructured data: resumes, LinkedIn profiles, cover letters

With a hybrid knowledge base, your app can answer:

"Which candidates are in New York and have experience in data analysis with Python?"

It will:

Filter by location == New York (structured)
Perform semantic search across profiles and resumes for "data analysis with Python" (unstructured)

📊✅ Combined results. No hacky joins. No second queries. Just clean, LLM-ready responses.

💡 Why It Matters

Most LLM apps fail when the data isn’t flat text.

Real-world knowledge is messy. It’s structured and unstructured.

And most stacks treat those as separate systems.

With Griptape Hybrid Knowledge Bases, you get:

A unified query layer
Tight integration with agents, workflows, and pipelines
Real-time, semantic + structured retrieval

Hybrid Knowledge Bases are now available in Griptape Cloud.

🙋‍♂️ What Would You Build?

Got a use case that blends structured and unstructured data?

Want to give your agents actual intelligence without cobbling multiple tools together?

Improving the dev experience for building apps that integrate up-to-date and private data with large language models

Kirk Crenshaw — Mon, 31 Mar 2025 20:25:51 +0000

We’re delighted to announce a new feature in Griptape Cloud that will improve the experience for developers building applications that integrate up-to-date and private data with large language models. Griptape Cloud has supported retrieval augmented generation applications through similarity search for some time. Check out this post for more details on existing Retrieval Augmented Generation features in Griptape Cloud > https://www.griptape.ai/blog/retrieval-augmented-generation-with-griptape-cloud

Retrievers
Today, we are adding to that capability with Griptape Cloud Retrievers. Retrievers are a fully-managed implementation of the RAG Engine within Griptape Framework, and add query modification, reranking capabilities, and the ability to apply rules to query responses. These features enable you to generate more accurate and tailored results in your RAG applications built with Griptape Cloud.

Query Modification
Query modification in RAG allows you to improve matching by transforming queries before embeddings are generated for the query and used for similarity search against the data stored in a vector store. They use techniques such as query expansion, where an LLM is used to add additional context or terms to improve each query; or Hypothetical Document Embedding (HyDE), which is the generation of hypothetical answers to a query, which are then embedded and used with the original query to enhance the query that is made against the vector store.

What is Reranking?
Reranking works by comparing the relatedness of search results returned from a vector search query to the original query and reordering the results in descending order of their relatedness. This gives a ‘reranked’ list of results that you can use in your application. Let’s explore an example of reranking with Griptape Framework to illustrate why reranking is valuable, and then we’ll move on to explain how to get started with Retrievers in Griptape Cloud. Let’s assume we asked the question “What is the capital of France?” and the results that came back from a vector search operation across our data sources were as follows:

results = [ “Hotdog", "San Francisco", "Lille", "Paris", "Rome", "Baguette", "Eiffel Tower", "French Hotdog" ]

To rerank these results, we compare the embedding for each result to the embedding for the original question “What is the capital of France?” and then order the results in descending order of relatedness. In this use-case, answering a question, we would likely use the top result, but there are other use-cases, a research agent might be one example, where we might want to take the top n results from the reranking operation to perform a secondary operation on those results.

Implementing reranking is simple with Griptape Framework. Griptape Framework supports reranking with a local rerank driver using a simple relatedness calculation, and also has the capabilities to use Cohere’s reranking model through the CohereRerankDriver. The sample code below uses the local rerank driver to rerank these results from the example query.

from griptape.artifacts import TextArtifact
from griptape.drivers.rerank.local import LocalRerankDriver

list = ["Hotdog","San Francisco","Lille","Paris","Rome","Baguette","Eiffel Tower","French Hotdog"]

artifact_list = []

for i in list:
   artifact_list.append(TextArtifact(i))

rerank_driver = LocalRerankDriver()

artifacts = rerank_driver.run("What is the capital of France?", artifact_list)

print("Reranked list:")

for artifact in artifacts:
    print("\t", artifact.value)
Reranked list:
         Paris
         Eiffel Tower
         Lille
         San Francisco
         Rome
         Baguette
         French Hotdog
         Hotdog

You can see that the reranking operation correctly identifies Paris as the best answer to the question that we posed.

The example above shows the LocalRerankDriver being used as a standalone module, but it is more commonly used within a Griptape Framework RagEngine. The code sample below shows how we might create a tool for an Agent to use where we define a RetrievalRagStage that includes a VectorStoreRetrievalRagModule and a TextChunksRerankRagModule, where we use the LocalRerankDriveras the rerank_driver.

rag_tool = RagTool(
   description="Contains information about the judgements and applications relating to legal cases",
   off_prompt=False,
   rag_engine=RagEngine(
       retrieval_stage=RetrievalRagStage(
           retrieval_modules=[
               VectorStoreRetrievalRagModule(
                   vector_store_driver=vector_store_driver,
                   query_params={"namespace": "legal documents", "top_n": 20},
               )
           ],
           rerank_module=TextChunksRerankRagModule(rerank_driver=LocalRerankDriver()),
       ),
       response_stage=ResponseRagStage(
           response_modules=[
               PromptResponseRagModule(
                   prompt_driver=OpenAiChatPromptDriver(model="gpt-4o")
               )
           ]
       ),
   ),
)

As we mentioned earlier, Retrievers are a fully-managed implementation of the RAG Engine within the Griptape Framework. So you don’t need to worry about this complexity if you’re using Griptape Cloud.

Query Response Types
Retrievers support two different response types, text chunk responses and prompts with rulesets. The Text Chunk response type is intended for use in conjunction with an LLM for Retrieval Augmented Generation use-case.

The Prompt with Rulesets response type is used to generate natural language responses to your queries directly from the Retriever without the need to pass text chunks to an LLM for response generation. As you might expect from the name of this response type, you can control the behaviour of the Retrieverer in generating natural language responses by attaching a Ruleset.

Using Retrievers in Griptape Cloud
Retrievers bring the benefits of query modification, reranking, and control over query responses to Griptape Cloud. Retrievers can rerank the results returned from multiple Knowledge Bases. This means that they are particularly valuable when combining the results from multiple different data sources where they can help ensure that your applications get the results that are most relevant to the search queries they are making.

Let’s walk through the process of setting up a Retriever on Griptape Cloud. In this example, we’re going to create a Retriever that uses the Knowledge Base that we configured when we set up the Assistant in the 'Brush Up on NVIDIA's Q4 Earnings’ sample on the Griptape Cloud console home page. If you want to learn more about that sample application, it’s covered in this blog post.

Retrievers can be found under the Libraries Navigation header in the left navigation menu in the Griptape Cloud Console. To create a Retriever, select the yellow highlighted option in the left navigation menu and then select Create Retriever on the Retrievers page.

You will then be prompted to provide the details for your new Retriever. We are going to create a Retriever for the RAG use-case that I will connect to an Assistant, so I completed the Retriever details as shown below. Once the details have been entered, click the Create button to create the Retriever.

I can then connect the new Retriever to my Assistant and use it to retrieve answers to my questions from the NVIDIA Q4 Earnings Knowledge Base.

In this example, I am using a Ruleset to guide the Assistants behavior. If you want to experiment with this, you can use my rules as inspiration for your own, or just copy them for yourself. The rules I used are as follows:

Only provide answers that you can verify using the Knowledge Base or Retriever. Check all answers against either the Knowledge Base or Retriever. If you cannot verify an answer from the Knowledge Base or Retriever, say so and decline to answer. Do not make things up that cannot be verified.
Only answer questions related to NVIDIA's Q4 2025 earnings. Decline to answer all other questions.

We hope you find the Griptape Cloud Retrievers a valuable addition to your RAG toolkit. As usual, we’re excited to hear how you put this new capability to work. Please join us in the Griptape Discord if you have any questions, or use-cases that you would like to share.

Announcing Griptape AI Framework 1.5

Kirk Crenshaw — Thu, 20 Mar 2025 19:37:37 +0000

We’re pleased to announce that Griptape Framework 1.5 is now available. The 1.5 release brings enhancements to embeddings to add support for generating image embeddings and the addition of image search via the framework’s vector store drivers. We also have updates to the default models in several drivers, support for Perplexity with a new prompt driver and web search driver, and more. Let’s head down to the skatepark and explore some of the new features added in this release.

Updated Getting Started Guide & Improved Samples
First up, we have improved the Griptape Framework getting started guide on the Framework Overview documentation page. The new guide uses the uv python dependency manager, though of course we also provide instructions for pip users, and provides a tour of the key features in the framework. We recommend that you check this out, even if you're already familiar with Griptape Framework, as it covers new features added over the last few releases. We have also updated all the code samples in the documentation to include a tab showing the output logs from running the sample, so you can see the results from each sample without having to run them yourself.

Support for Image Embeddings
Griptape Framework 1.5 includes support for generating embeddings from ImageArtifact objects, together with new embedding drivers for Amazon Bedrock with Amazon’s Titan Multimodal Embeddings G1 model, and for Voyage AI’s voyage-multimodal-3 model.

In the example below, I generate embeddings for 4 images that I generated using FLUX.2 with the Black Forest Labs extension for Griptape. After generating and saving two snowboarding images and two skateboarding images, in the code sample I use Amazon’s amazon.titan-embed-image-v1 model to calculate embeddings for these images and a simple relatedness calculation to compare the vectors that the embedding model generated.

from griptape.drivers.embedding.amazon_bedrock import AmazonBedrockTitanEmbeddingDriver
from griptape.loaders import ImageLoader
import numpy as np

def calc_relatedness(
   x, y
):  # using the same relatedness function as the localrerankdriver
   return np.dot(x, y) / (np.linalg.norm(x) * np.linalg.norm(y))

# create a driver for multi-modal embedding with Amazon Bedrock and Amazon Titan
multi_modal_embedding_driver = AmazonBedrockTitanEmbeddingDriver(
   model="amazon.titan-embed-image-v1"
)

# calculate embeddings for our four sample images
blue_snowboarder_embeddings = multi_modal_embedding_driver.embed(
   ImageLoader().load("images/blue_snowboarder.jpeg")
)
orange_snowboarder_embeddings = multi_modal_embedding_driver.embed(
   ImageLoader().load("images/orange_snowboarder.jpeg")
)
beach_skater_embeddings = multi_modal_embedding_driver.embed(
   ImageLoader().load("images/beach_skater.jpeg")
)
paris_skater_embeddings = multi_modal_embedding_driver.embed(
   ImageLoader().load("images/paris_skater.jpeg")
)

print(  # compare the two snowboarding images
   "blue_snowboarder vs orange_snowboarder: ",
   calc_relatedness(blue_snowboarder_embeddings, orange_snowboarder_embeddings),
)

print(  # compare a snowboarding image with a skateboarding image
   "blue_snowboarder vs beach_skater: ",
   calc_relatedness(blue_snowboarder_embeddings, beach_skater_embeddings),
)

print(  # compare the two skateboarding images
   "beach_skater vs paris_skater: ",
   calc_relatedness(beach_skater_embeddings, paris_skater_embeddings),
)

The results are that the two snowboarding images are very related with a score of greater than 0.9 (scores closer to 1 indicate higher levels of relatedness), while the comparison of the snowboarding and skateboarding images gives a score just over 0.55. Comparing the two skateboarding images generates a relatedness score of greater than 0.75, despite one being on Santa Monica beach and the other in the skatepark at the Paris Olympics.

Here are the images, together with the results for you to take a look at. I really like the results that I got with Black Forest Labs, and the results from the relatedness calculations.

In addition to the changes to embedding drivers, vector store drivers have been updated to support upserting and querying with ImageArtifact objects, and the framework’s local vector store has been updated to support persisting multi-modal entries. These changes mean that you can store the embeddings generated for the images into a vector store and then you can query this to find the top x images nearest to the embeddings for a query image. These changes enable Griptape Framework to support image-based use cases such as image similarity search.

Support for Perplexity
In this release we’ve added support for the popular AI-powered search and research engine, Perplexity, with the addition of PerplexityPromptDriver and PerplexityWebSearchDriver.

import os

from griptape.drivers.prompt.perplexity import PerplexityPromptDriver
from griptape.rules import Rule
from griptape.structures import Agent
from griptape.tasks import PromptTask

agent = Agent(
   tasks=[
       PromptTask(
           prompt_driver=PerplexityPromptDriver(
               model="sonar-pro", api_key=os.environ["PERPLEXITY_API_KEY"]
           ),
           rules=[
               Rule("Be precise and concise"),
           ],
       )
   ],
)

agent.run("tell me about the griptape framework 1.4 release")

print(agent.output.value)

If you experiment with the PerplexityPromptDriver using the code sample above, you will notice that the responses are generated using search as well as an LLM, meaning that you get up-to-date answers from the web. In this case, the model does a great job finding some of the highlights from the last release of the framework, using the blog post about that release as a source. This makes the PerplexityPromptDriver a little different to the other prompt drivers in Griptape Framework. We are excited to see what you build with this exciting new capability.

Updates to Default Models
The default model in the AnthropicPromptDriver has been updated to claude-3-7-sonnet-latest.

If you're using Google models, the default model for the GooglePromptDriver has been updated to gemini-2.0-flash and the default model for the GoogleEmbeddingDriver has been updated to embedding-004.

For developers using Amazon Bedrock to access Anthropic’s model, the default model in the AmazonBedrockPromptDriver has been updated to anthropic.claude-3-7-sonnet-20250219-v1:0. In addition, the Amazon Titan model used for text embeddings has been updated to amazon.titan-embed-text-v2:0 and the default Amazon Titan model used in the AmazonBedrockImageGenerationDriver has been updated to amazon.titan-image-generator-v2:0.

As usual, you can continue to use previous generation models by setting the model keyword argument to the model that you wish to use when creating an instance of each driver.

Improved Control over Tool Use
If you’ve having trouble getting less powerful LLMs to function correctly when calling tools, the 1.5 release allows you to set reflect_on_tool_use to False and have the LLM return tool outputs directly. If you're using a less powerful LLM, you should consider using this setting so that you can make tool calls yourself rather than having the LLM coordinate them. In the very simple code sample below I run three tasks where I provide a DateTimeTool. The code is commented to provide details on the behavior that you should expect, and you can see the results from running this sample below the sample.

from griptape.tasks import PromptTask
from griptape.tools import DateTimeTool
from griptape.artifacts.list_artifact import ListArtifact

# When disabling `reflect_on_tool_use`, Task results will be returned as a ListArtifact.
# Each item in the ListArtifact will be the result of a single tool execution.

date_task = PromptTask(
    tools=[DateTimeTool()],
    reflect_on_tool_use=False,
)
results = date_task.run("How many days until it's 2026?")
# This will fail as the model will not reflect and figure out that an additional tool run is needed to calculate the date delta

if isinstance(results, ListArtifact):
    for result in results:
        print("Simple prompt output without reflection:", result)

date_task = PromptTask(
    tools=[DateTimeTool()],
    reflect_on_tool_use=False,
)
results = date_task.run("How many days from 12:44 on March 19th 2025 to Jan 1st 2026?")
# This will succeed as the prompt is more specific and the model can calculate the date delta using a single tool invocation
# Note that the output is the raw output from the tool

if isinstance(results, ListArtifact):
    for result in results:
        print("Detailed prompt output without reflection:", result)

date_task = PromptTask(
    tools=[DateTimeTool()],
    reflect_on_tool_use=True,
)
results = date_task.run("How many days until it's 2026?")
# This will succeed as the model will invoke the tool multiple times to get the current date & calculate the date delta
# Note that the output is more descriptive as the model has reflected on the final tool inovcation to generate the response

print("Simple prompt output with reflection:", results)
Simple prompt output without reflection: 2025-03-19 12:47:10.882934

Detailed prompt output without reflection: 287 days, 11:16:00

Simple prompt output with reflection: There are 287 days until it's 2026.

‍How to get started
Griptape Framework 1.5 is available now and you can download it with uv, poetry, pip or another Python package manager of your choice. As usual, we would love to hear your feedback on these changes, together with ideas and suggestions for future imrpovements to the framework. If you want to ask any questions about the other features in this release or discuss your image embedding use-cases, please head over to the Griptape Discord.

Griptape vs. LangChain, CrewAI, and LlamaIndex: Which AI Framework Performs Best?

Opemipo Disu — Tue, 22 Oct 2024 10:37:25 +0000

TL;DR

This article compares Griptape Framework with three popular AI frameworks; LangChain, CrewAI, and LlamaIndex, focusing on scalability, performance, and code complexity. In the end, you will learn why Griptape offers a more straightforward, faster, and more scalable framework for developing AI applications.

Introduction

In recent times, AI frameworks have transformed the development and deployment of AI applications, making it easier to manage workflows, build pipelines, and integrate complex LLMs into existing applications. Each of these frameworks has unique qualities and strengths that can be leveraged to build different AI projects.

These frameworks have been helpful to developers looking to streamline AI development by integrating LLMs, automating tasks, and reducing development time. They also simplify workflows and pipelines, allowing developers to focus more on building AI applications.

In this article, we will compare these frameworks, focusing on their performance and ease of use for developers. We’ll explore how Griptape framework stands out, making it a better option than other AI frameworks for building interactive AI applications.

Overview of Griptape Framework

Griptape framework is an open-source AI framework that is designed to enhance the performance of AI applications by reducing code complexity and integrating LLMs into configurable workflows and pipelines. With the framework, developers can create interactive AI applications that efficiently handle and secure data..

Griptape takes care of optimizing AI models and other high-level stuff, while developers can focus on lower-level complexities, such as building the business logic, orchestrating workflows and managing integrations with LLMs.

The framework enables developers to code in Python and work with external data and APIs to generate responses. It also supports RAG pipelines, enabling responses from external sources, which makes it a flexible platform.

Griptape’s Official Website.

Yes, one more thing 😃.

Give Griptape a Star on GitHub 🙏

I will appreciate it if you become one of Griptape’s stargazers on GitHub. This will help a lot in Griptape’s growth - each star goes a long way toward making Griptape a more popular framework. 🚀

Star Griptape on GitHub 🌟

Overview of LangChain

LangChain is a popular and powerful open-source framework that enables developers to build AI applications with LLMs. It is a great choice for creating dynamic pipelines for AI applications, enabling tasks like natural language processing and conversational agents.

LangChain can also connect LLMs to external data and APIs, providing additional context to responses. Its flexibility and support for numerous integrations have made it a popular choice among developers for building complex AI applications.

Currently, LangChain supports both Python and JavaScript, making it a flexible option for developers who want to build AI applications across different environments.

LangChain’s Official Website.

Overview of CrewAI

CrewAI on the other hand is an AI platform designed to streamline team collaboration and project management. It provides an open-source Python framework that enhances workflow efficiency by automating repetitive tasks With CrewAI, teams can manage projects more effectively by predicting timelines, defining tasks, and distributing roles.

CrewAI easily connects with LLMs, project management tools, and APIs, helping teams centralize their work and improve coordination. Its AI-powered analytics assist teams in making smart decisions, leading to smoother project execution and better goal alignment.

CrewAI’s flexible setup works well for teams of any size, making it useful for both small startups and large enterprises. The platform lets organizations scale easily, while getting real-time insights to improve performance.

CrewAI’s Official Website.

Overview of LlamaIndex

LlamaIndex is an open-source framework that helps developers build systems to find and retrieve information using large language models (LLMs). It makes it easy to create pipelines for searching, indexing, and retrieving data from different sources, making it a powerful tool for AI-driven applications.

LlamaIndex works well with external sources such as datasets, APIs, and knowledge bases, allowing LLMs to access and search both structured and unstructured data. This helps developers build smart systems that can give accurate, data-based answers.

LlamaIndex supports two programming languages: TypeScript and Python, making it a flexible tool for developers who use both technologies to build applications.

LlamaIndex’s Official Website.

Understanding The Frameworks

In this section, we will take a deep dive into each framework. You’ll learn more about their architectures, strengths, and specific use cases, helping you better understand how they perform and where they stand out.

Griptape Framework

Architecture

Griptape Framework is an open-source framework. The Griptape framework is designed with modularity and cloud integration, especially with Griptape Cloud; its modularity makes it flexible to work with LLMs. At its core level, Griptape applications are structured around workflows and pipelines that include manageable components.

These workflows enable developers to define tasks, data flows, and logic that interact with LLMs and external systems. Griptape’s framework also provides a feature for memory management, Task Memory. It ensures that workflows can maintain context and share data between tasks.

The TaskMemory approach is mostly useful for applications that work with LLMs, where maintaining context across multiple interactions is essential for generating logical responses.

The Griptape Framework mostly focuses on simplicity and performance. Its lightweight nature makes it more performant compared to other frameworks. The Griptape framework is known for minimizing code complexity in Gen AI applications.

Lastly, the framework is a fit for high-performance AI applications that need to scale properly.

Key Features of Griptape Framework

Scalability: The Griptape Framework is designed to handle large datasets and huge tasks, making it suitable for any type of application, from small AI applications to enterprise-level applications. Its architecture enables developers to scale their AI applications seamlessly as data and workloads grow, without reducing performance.
Minimal Code: One of the most exciting features of Griptape is its capability to reduce the amount of code needed to build AI workflows. For example, it provides a seamless integration with AI models.
By minimizing code, developers can focus more on application logic, reducing development time and reducing complexities.
Performance: One of the most notable features the Griptape Framework provides is its high efficiency. Griptape is optimized for speed, often performing up to 10x faster than other frameworks, particularly in AI workflows integrating with LLMs.
Task Memory: Task Memory is one of the most useful features of the Griptape Framework. It enables workflows to maintain context and state, enhancing the efficiency of AI applications.
By storing intermediate results and enabling task communication, Task Memory ensures that each step in a workflow can access and build upon previous inputs and outputs.

LangChain

Architecture

LangChain is designed to be a modular framework, offering a flexible architecture that allows developers to easily integrate and customize components based on their specific use cases. The framework is designed to work with different models and APIs, making it adaptable to different types of AI workflows.

Like Griptape, LangChain’s modularity enables seamless chaining and integration with different models, prompts, and data sources.

LangChain currently supports two programming languages: JavaScript and Python. This enables developers using either language to easily build AI applications across these stacks. Whether you're working with the JavaScript or Python frameworks, LangChain provides the same functionalities, ensuring that developers can achieve the same results regardless of the frameworks they choose.

Key Features of LangChain

LLM Integration Layer: At its core, LangChain is built around the idea of relying on LLMs to generate responses. This integration layer handles the interaction with LLMs through APIs, ensuring that developers can easily plug in different models, making it simple to use LLMs without manual configuration or complexity.
Multilingual Support: As mentioned earlier, LangChain provides two frameworks—one for Python and another for JavaScript. With both frameworks, you’ll get the same results; the only difference is the syntax. Code complexity may also vary because of the two different underlying technologies.
Chains for Workflow Orchestration: Beyond LLM integration, LangChain allows developers to connect various components in a sequence, enabling workflow orchestration. This chaining of components facilitates the creation of more complex AI workflows, where data flows from one task to the next.
LangChain Memory: This is still in its beta version, LangChain Memory allows conversational AI applications to "remember" previous conversations, making it possible to maintain context in multi-turn conversations. This is mostly useful for virtual assistants that need to store information across different sessions to improve response relevance.

LlamaIndex

Architecture

LlamaIndex is a framework designed to manage large-scale datasets and integrate with AI models. It provides tools for data management, mostly for applications that require querying and processing large amounts of structured and unstructured data. However, LlamaIndex does not perform as efficiently when handling high-speed AI model execution compared to Griptape.

Like LangChain, LlamaIndex provides a framework for two underlying stacks; Python and TypeScript. These stacks are designed to be lightweight, allowing easy interaction with LLMs while ensuring developers can work with TypeScript and JavaScript.

LlamaIndex stands out at connecting LLMs with large datasets for real-time and context-driven retrieval, making it a great tool to use for AI applications that require access to external sources.

Key Features of LlamaIndex

Now, let’s have a look at the best attributes of LlamaIndex:

Language Flexibility: LlamaIndex has a framework for two underlying technologies; JavaScript and TypeScript, providing flexibility for developers who prefer either language.
Lightweight Nature: LlamaIndex is designed to be lightweight, allowing developers to build applications without the overhead of a large framework. Its simplicity makes it a great framework for developers working on AI projects that require a direct connection between LLMs and data sources.
Query Optimization: The query layer facilitates the interaction between the user’s prompt or question and large datasets. It ensures that LLMs can generate relevant information from the index, enabling natural language querying and retrieval.

CrewAI Framework

Architecture

CrewAI Framework is an open-source framework solely for team collaboration. The framework integrates with LLMs and models, providing a structure that allows different models to solve complex tasks.

CrewAI's Framework modularity makes it easy to connect with datasets and APIs. It allows AI workloads to scale across teams. Designed for real-time collaboration, CrewAI is good for projects that need input from multiple models or data streams.

CrewAI also takes in a pipeline-based workflow, allowing developers to chain tasks, automate processes, and ensure smooth data flow through different models and stages of building the AI application. Lastly, CrewAI’s framework runs on Python; it can only run in a Python environment.

Key Features of CrewAI Framework

Collaboration Driven: CrewAI is designed for teams that want to collaborate on building AI projects. It supports workflows where different members can contribute to various parts of the project in real-time, enabling seamless collaboration across teams. CrewAI’s infrastructure enables AI agents to distribute roles and work together, regardless of the project the team is working on. This feature helps streamline development and speeds up project completion.

Modular Architecture: Just like LangChain and Griptape, CrewAI’s framework offers a modular setup that enables seamless integration of different AI models, APIs, and external data sources. This architecture enables developers to configure and scale their AI projects efficiently.
Real-Time Data Integration: CrewAI enables seamless real-time data processing, making it a great tool to use for dynamic applications. This capability ensures that AI models can interact with data that constantly changes.

Metrics for Comparison

Now, we will evaluate Griptape, LangChain, LlamaIndex, and CrewAI. We will look into some key metrics to see which one stands out best. These metrics will provide a clear picture for each framework’s strengths and weaknesses for building AI applications.

Scalability

Griptape Framework: Griptape framework stands out in scalability when working with applications that need to manage large datasets and handle high-level tasks. It’s built for real-time data processing and large-scale deployments, enhanced further by Griptape Cloud. Its lightweight framework minimizes overhead, making it an efficient tool for managing AI workloads without sacrificing performance.
LangChain: LangChain is also scalable but it requires more manual configuration to manage large workloads. Due to its complex modular architecture, it can struggle with large-scale applications unless configured properly. LangChain’s strength in scalability relies on the developer’s ability to manually configure components.
LlamaIndex: LlamaIndex is built for document retrieval, making it highly scalable for use cases focused on querying large datasets. Its scalability for general AI tasks may not be as strong compared to Griptape framework or LangChain.
CrewAI: CrewAI is great for scaling complex AI workflows and data pipelines with multiple integrations. However, setting it up and managing large projects can be more complex and require more effort compared to Griptape.

Performance

Griptape: Griptape is highly performant, it often completes tasks up to 10x faster than other major AI frameworks. This is due to its lightweight nature, which reduces latency and maximizes performance rate. Griptape's design allows it to deliver results efficiently without the need for additional layers of manual configuration.
LangChain: LangChain is powerful and flexible, but its modular architecture can introduce complexities, which may affect performance if not optimized. Integrating multiple components can slow down execution, especially for simpler tasks where a smaller framework might be more efficient. Proper configuration is important for maintaining performance with larger workflows.
LlamaIndex: LlamaIndex works great for document-related applications, especially when dealing with large data sets. However, it’s not as fast for general AI tasks because its design is more suited for data retrieval than real-time language tasks.
CrewAI: CrewAI’s performance is dependent on how well the application is configured. It can achieve high performance for complex tasks, but this comes with more complex learning process and configuration time. For basic applications, it doesn’t perform as quickly as Griptape or LlamaIndex due to its more complex workflows.

Code Complexity

In this section, we will have a look at how quickly it is to setup code for implementing the same solution for all frameworks. If you’re a developer, you will understand that simpler frameworks enable faster development cycles, fewer bugs, and easier maintenance.

We will create a simple calculator that solves simple arithmetic equations with each of these frameworks and compare their code complexities.

Griptape:

from griptape.tools import Calculator
from griptape.structures import Agent
agent = Agent(
    tools=[Calculator()]
)
def calculator_loop():
    print("welcome to Griptape calculator")
    print("type 'exit' to quit the calculator")
    while True:
        user_input = input("input a calculation like 5 + 3 * 2:")        
        if user_input.lower() == 'exit':
            print("bye!")
            break
        try:
            response = agent.run(user_input)
            result = response['output']
            print(f"Result: {result}")  
        except Exception as e:
            print(f"Error: {e}")
calculator_loop()

LangChain:

from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
model = ChatOpenAI(model="gpt-4")
prompt_template = PromptTemplate(
    input_variables=["expression"],
    template="Calculate this expression: {expression}."
)
chain = LLMChain(llm=model, prompt=prompt_template)
def evaluate_expression(expression: str) -> str:
    response = chain({"expression": expression}) 
    return response['text'].strip() 
if __name__ == "__main__":
    print("Welcome to the Interactive Calculator!")
    print("Type 'exit' to quit.")
    while True:
        expr = input("Enter a numerical expression to evaluate: ")
        if expr.lower() == "exit":
            print("Exiting the calculator. Goodbye!")
            break
        try:
            result = evaluate_expression(expr)
            print(f"Result: {result}")  
        except Exception as e:
            print(f"Error: {e}. Please enter a valid numerical expression.")

LlamaIndex:

from llama_index.core.agent import ReActAgent
from llama_index.llms.openai import OpenAI
from llama_index.core.tools import FunctionTool
def multiply(a: int, b: int) -> int:
    return a * b
def add(a: int, b: int) -> int:
    return a + b
def subtract(a: int, b: int) -> int:
    return a - b
def divide(a: int, b: int) -> float:
    if b == 0:
        raise ValueError("Cannot divide by zero.")
    return a / b
multiply_tool = FunctionTool.from_defaults(fn=multiply)
add_tool = FunctionTool.from_defaults(fn=add)
subtract_tool = FunctionTool.from_defaults(fn=subtract)
divide_tool = FunctionTool.from_defaults(fn=divide)
llm = OpenAI(model="gpt-4")
agent = ReActAgent.from_tools(
    [multiply_tool, add_tool, subtract_tool, divide_tool],
    llm=llm,
    verbose=True
)
def evaluate_equation(equation: str):
    try:
        response = agent.chat(f"Given the equation {equation}, calculate it step by step.")
        print("Calculation Result:")
        print(response)
    except Exception as e:
        print(f"Error: {e}")
def parse_equation(equation: str):
    tokens = []
    num = ''
    for char in equation:
        if char.isdigit() or char == '.':
            num += char
        else:
            if num:
                tokens.append(num)
                num = ''
            tokens.append(char)
    if num:
        tokens.append(num)
    return tokens
while True:
    user_input = input("Please enter an equation (e.g., 5 + 3 * 2) or type 'exit' to quit: ")

    if user_input.lower() == 'exit':
        print("Exiting the program.")
        break
    equation = user_input.replace(" ", "")
    tokens = parse_equation(equation)
    evaluate_equation(' '.join(tokens))
    print("\nWould you like to perform another calculation? (yes/no)")
    continue_input = input().lower()
    if continue_input not in ['yes', 'y']:
        print("Exiting.")
        break

CrewAI:

import os
from crewai import Agent, Task, Crew, Process
calculator_agent = Agent(
    role='Calculator',
    goal='Perform arithmetic operations from given equations.',
    verbose=True,
    memory=False,
    backstory='You are designed to handle calculations efficiently by processing equations.'
)
class CalculationTask(Task):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
    def execute(self, inputs):
        equation = inputs.get('equation')
        try:
            result = eval(equation)
        except Exception as e:
            result = f"Error evaluating equation: {str(e)}"
        return f"The result of the equation '{equation}' is: {result}"
calculation_task = CalculationTask(
    description="Evaluate the equation: {equation}.",
    expected_output="The result will be calculated.",
    agent=calculator_agent
)
crew = Crew(
    agents=[calculator_agent],
    tasks=[calculation_task],
    process=Process.sequential
)
def run_terminal_calculator():
    while True:
        equation = input("Enter the equation to calculate (or type 'exit' to quit): ")
        if equation.lower() == "exit":
            print("Exiting the calculator. Goodbye!")
            break
        inputs = {
            'equation': equation
        }
        result = crew.kickoff(inputs=inputs)
        print(result)
if __name__ == "__main__":
    run_terminal_calculator()

While they all perform the same function of solving arithmetic equations, they all have different ways of implementation due to the nature of the frameworks. While the basic implementations are straightforward, leveraging the GPT-4 model for more dynamic interactions brings in added complexities around integration and syntax.

Griptape Framework focuses on simplicity and ease of use. The code for setting up a calculator using Griptape is straightforward, with just a few lines to define the agent and run a loop to keep interacting with the user after every calculation. The implementation has just 20 lines of code and it is easy to use. Additionally, the code didn’t include any manual integration with any LLM; the Griptape framework works with OpenAI’s GPT-4 by default.

Basic error handling is also included, and the framework ensures you can manage errors without any complex setup.

LangChain, on the other hand, offers flexibility but comes with increased complexity. Since LangChain is designed to integrate with language models, there’s a little more setup involved in defining prompts and handling responses from the model.

While LangChain is simple to set up, it introduces some complexity with the need to define a prompt template and chain execution - the code isn’t as concise as what we have for Griptape; it has almost 30 lines.

LlamaIndex combines the calculator with model interaction. It lets you set up function tools and use models for more complex tasks. While the implementation is more complex compared to Griptape and LangChain, the code has 58 lines.

The code also includes more complex error handling, it requires manual effort to define each function tool and handle some cases like dividing by zero. 😃

CrewAI focuses on agents and tasks, making it the most complex framework in this comparison. Even the simple calculator setup needs agents, tasks, and process flows, despite using fewer lines of code than LlamaIndex. The code in the snippet is 42 lines majorly due to defining classes for the Agent, Task, and process flow.

Summary

While comparing these frameworks in this article — Griptape, LangChain, LlamaIndex, and CrewAI, we can see that they have their strengths and weaknesses depending on the use case. However, we explored the key metrics developers consider before choosing a tool to work with; Griptape, LangChain, LlamaIndex, and CrewAI.

Objectively, Griptape framework stands out as the best option among all the frameworks. Its focus on reducing code complexity while providing powerful features such as TaskMemory, high performance in LLM integrations, and scalability make it the best choice for building interactive AI applications.

LangChain provides great flexibility but is more complex. LlamaIndex is great for data retrieval but lacks versatility for general AI applications. CrewAI is ideal for team collaboration and role distribution but can introduce unnecessary overhead for simpler use cases.

For developers looking to build scalable and high-performance AI applications with minimal complexity, Griptape is the clear winner! 🎉

In conclusion, while each framework has its unique advantages, Griptape's combination of simplicity, efficiency, and powerful features makes it a good choice for developers eager to explore its capabilities. To get started with Griptape you can go through its documentation.

I hope you enjoyed every single bit of this article. Please, note that opinions in this article are objective. I’ll appreciate your comments and reactions - hope to have you read the next piece. See ya! 👋

References

Griptape: OSS Platform for Building AI Apps

Opemipo Disu — Wed, 09 Oct 2024 18:01:34 +0000

Over the past few weeks, I spent a lot of time exploring new AI tools with which I could build a Gen AI application. Of the many AI tools I found, Griptape impressed me the most. Wondering why I got interested in Griptape? You will find out what makes it special and my reason for using it.

TL;DR 🧏🏽

In this article, you will learn about Griptape, its core components, and how to kickstart building and deploying your first AI application with Griptape and your favorite LLM.

Curious to see what Griptape offers? Let’s dive in!

Introduction to Griptape

Griptape is a powerful platform for building, deploying, and managing AI applications with ease — it provides its users with a framework that helps simplify complexities of building AI applications and a cloud infrastructure for seamless deployment of Griptape applications.

With Griptape, you don’t need to worry about managing the underlying infrastructure as the framework takes care of it. The platform is a great choice for developers and teams that want to accelerate development of AI applications. Griptape’s modularity ensures it remains lightweight, making it perfect for building high-performance applications without unnecessary overhead.

Griptape Framework

The Griptape framework is an open-source Python framework designed to facilitate AI development. It makes it easy to integrate LLMs into applications with manageable pipelines and workflows. With the framework, developers can create conversational AI agents and other generative AI applications to handle data securely and efficiently.

The Griptape framework allows developers to integrate LLMs with third-party data sources or custom AI models. All you have to do is build Extract, Transform, Load (ETL) pipelines to protect access to LLMs and write agents, workflows, and pipelines to integrate your custom business logic.

Griptape Cloud

Griptape provides a cloud infrastructure that enables developers to deploy and scale their applications without worrying about infrastructure management. The platform takes care of resource allocation, load balancing, and uptime management, allowing developers to focus on building, deploying, and managing their applications with ease.

Griptape's cloud infrastructure supports Retrieval-Augmented Generation (RAG) pipelines, which are particularly useful for pre-processing information from external data sources before generating responses. This process allows developers to retrieve relevant data, integrate it with the response generation, and plug it seamlessly into client applications, creating more dynamic and data-enriched responses.

In addition, it lets you connect to external data sources, therefore, allowing you to extract and refine data. Whether you're deploying lightweight or complex AI agents, the cloud infrastructure automatically adjusts to handle increased demand, ensuring seamless performance.

Key Feature of Griptape

Griptape provides many features to its users:

LLM Integration (Framework): Griptape simplifies working with LLMs by reducing the code needed for integration. The framework allows you to easily integrate an LLM into your applications, enabling them to generate responses and context and perform other supported tasks efficiently.
Infrastructure Management (Cloud): You do not need to worry about this when using Griptape because Griptape Cloud helps manage all the infrastructure tasks and load, including uptime management and resource allocation. This helps save time, as the developer’s focus will be centered on the application’s development.
Scalability (Cloud): Griptape Cloud automatically scales to meet your application's demands without any manual configuration. This seamless scaling doesn't compromise performance, ensuring your Griptape application runs smoothly even as demand increases. Your application remains responsive and efficient as resources are dynamically adjusted to ensure optimal performance. Whether you are building a large-scale AI application or not, there’s nothing to worry about — Griptape Cloud manages everything for you.
Modular and Lightweight (Framework): The Griptape framework was designed to be modular and lightweight for high performance and flexibility in development. With its modular approach, you only need to integrate the components developers need, saving time and reducing overhead. The framework’s lightweight structure ensures that complex AI workflows and pipelines can be developed and executed without reducing performance quality, making it ideal for any type of project.
Open-source (Framework): Griptape's framework is open-source, making it flexible for development. Developers can make contributions to extend Griptape's capabilities. Contributions such as GitHub issues or bug fixes can also be made to the repository.
Pipeline & Workflow Management (Framework): The framework enables developers to build and manage workflows and pipelines securely and efficiently. With the help of Griptape’s off-prompt (Griptape’s component designed for security and higher performance), developers have control over the data that goes into the LLM and ensure processes run smoothly. The off-prompt feature also allows for seamless orchestration of tasks, enabling applications to process any amount of data and handle complex workflows.
RAG Pipeline Optimization Support and Optimization: Griptape’s framework supports RAG pipelines, enabling developers to generate relevant responses from external sources. The support allows for flexibility from different sources outside the LLM. In addition, Griptape Cloud improves the quality of RAG pipelines making it easy to compile data before generating responses, improving the relevance and accuracy of the responses.
Seamless Deployment (Cloud): Developers can easily deploy Griptape applications using the Cloud Infrastructure without the need for manual configuration or complexities, simplifying the entire deployment process.
Griptape TaskMemory: This is a configurable feature provided by the Griptape Framework for storing and retrieving information generated during task execution within workflows, without sending any data back to the LLM. By using TaskMemory, developers can easily manage the state between different tasks without needing to manually track it across different stages. This feature also serves as a cost-effective solution for teams using LLMs, as the costs are based on token counts (the amount of data LLMs use for input and output) of the messages sent.

Give Griptape a Star on GitHub 🙏

As mentioned earlier, Griptape is open-source; all contributions are appreciated. You can support Griptape by giving It a Star on GitHub.

Griptape’s growth since its start in April 2023 🚀

Want to be a part Griptape’s growth? Please help Griptape grow by giving the project a Star on GitHub.

Star Griptape on GitHub 🌟

Now that you know about Griptape, its major components, and key features, it’s time to get our hands a bit dirty by creating a simple AI application with Griptape’s Framework.

Developing an AI Application Using Griptape and an LLM 🧙‍♀️

Building an application with Griptape is straightforward - you only need to integrate an LLM into your AI application. Here is a step-by-step guide of how to develop a simple calculator using Griptape and an LLM:

Install and Setup Griptape Framework: You’ll need to install Griptape Framework into your application using Python’s package manager:

pip install "griptape[all]" -U

Get Your OpenAI API key and Add to your Environment: If you have an OpenAI account, generate a secret API key. Griptape uses OpenAI’s Chat Completion API to execute LLM tasks. The command below establishes a connection between OpenAI and Griptape by adding your API key to your environment:

export OPENAI_API_KEY=’YOUR_API_KEY’

Importing necessary Griptape Modules: Here comes the first of the major steps; writing some Python code that leverages Griptape’s Framework and gpt-4 to perform tasks. Since we are building a simple calculator, we will make imports from two Griptape modules:

from griptape.tools import Calculator
from griptape.structures import Agent

In the code above, we will import the Calculator tool from the griptape.tools module. This tool is designed to perform arithmetic functions in Griptape.

The Agent class was also imported from the griptape.structures module for making interactions between the user and the Calculator tool by taking in calculations and generating responses.

Creating an Agent: After importing the modules, you need create an agent with the Agentclass imported.

agent = Agent(
    tools=[Calculator()]
)

The Agent works directly with the Calculator tool to provide input, while the Calculatortool performs calculations based on the user’s command.

Defining the Calculator’s Loop: We will create a function to print the main logic of the calculator. In this loop, we will print the instruction for the user.

def calculator_loop():
    print("welcome to Griptape calculator")
    print("type 'exit' to quit the calculator")

Create User Interaction: We will initiate a while loop that enables continuous interaction with the user even after getting responses. The loop will only be terminated if the user inputs “exit”, this end the session as well by printing “bye!”.

while True:
    user_input = input("input a calculation like 5 + 3 * 2: ")        
    if user_input.lower() == 'exit':
        print("bye!")
        break

Handling User Input: Now let’s create a logic to make user input perform calculations. The user’s input is passed to the agent’s agent.run(user_input)method that process the calculation using the Calculation tool integrated into the Agent class. Once the agent has processed the inputted calculation, it is expected to display a key as output. In the end, the result will be extracted and printed in a readable format. One thing also added to the code below is a logic to handle errors; once there is an error. it notifies the user in a friendly way.

        try:
            response = agent.run(user_input)
            result = response['output']

            print(f"Result: {result}")  
        except Exception as e:
            print(f"Error: {e}")

Run the Calculator Loop: Lastly, we will create a calculator loop to restart the calculator after performing

calculator_loop()

This is the code you should have before running or deploying:

from griptape.tools import Calculator
from griptape.structures import Agent

agent = Agent(
    tools=[Calculator()]
)

def calculator_loop():
    print("welcome to Griptape calculator")
    print("type 'exit' to quit the calculator")

    while True:
        user_input = input("input a calculation like 5 + 3 * 2:")        
        if user_input.lower() == 'exit':
            print("bye!")
            break
        try:
            response = agent.run(user_input)
            result = response['output']

            print(f"Result: {result}")  
        except Exception as e:
            print(f"Error: {e}")

calculator_loop()

Now, let’s run the script and test our first Griptape Application:

python3 my_griptape_script.py

Finally, let’s test our first Griptape application:

Welcome to Griptape Calculator
Type 'exit' to quit the calculator.
Input a calculation like 5 + 3 * 2: 83 - 10 * 2 + 4 / 2
[10/04/24 00:47:03] INFO     ToolkitTask 038e687684c04ae2b83467221ca9f6c4                                                                                               
                             Input: 83 - 10 * 2 + 4 / 2                                                                                                                 
[10/04/24 00:47:08] INFO     Subtask 989a11849ec3406f85b5db3de17089bf                                                                                                   
                             Thought: To solve the expression \(83 - 10 \times 2 + \frac{4}{2}\), I need to follow the order of operations: parentheses, exponents,     
                             multiplication and division (from left to right), and addition and subtraction (from left to right).                                       

                             1. First, perform the multiplication: \(10 \times 2\).                                                                                     
                             2. Then, perform the division: \(\frac{4}{2}\).                                                                                            
                             3. Finally, perform the subtraction and addition in sequence.                                                                              

                             Actions: [{"name":"Calculator","path":"calculate","input":{"values":{"expression":"10 *                                                    
                             2"}},"tag":"multiplication"},{"name":"Calculator","path":"calculate","input":{"values":{"expression":"4 / 2"}},"tag":"division"}]          
[10/04/24 00:47:10] INFO     Subtask 989a11849ec3406f85b5db3de17089bf                                                                                                   
                             Response: Output of "Calculator.calculate" was stored in memory with memory_name "TaskMemory" and artifact_namespace                       
                             "ec34a8df918c41c18ae2f53f0654b611"                                                                                                         

                             Output of "Calculator.calculate" was stored in memory with memory_name "TaskMemory" and artifact_namespace                                 
                             "e2ce65a931e34b36bda8c62063621fc1"                                                                                                         
[10/04/24 00:47:12] INFO     Subtask bf8589416c6f4f6487d22dc7b217b599                                                                                                   
                             Thought: I have the results of the multiplication and division stored in memory. I need to retrieve these results and use them to complete 
                             the calculation for the expression \(83 - 20 + 2\).                                                                                        

                             Actions: [{"tag": "subtraction_addition", "name": "Calculator", "path": "calculate", "input": {"values": {"expression": "83 - 20 + 2"}}}]  
                    INFO     Subtask bf8589416c6f4f6487d22dc7b217b599                                                                                                   
                             Response: Output of "Calculator.calculate" was stored in memory with memory_name "TaskMemory" and artifact_namespace                       
                             "d29c94ed49f84111ae76f02ae94e7df2"                                                                                                         
[10/04/24 00:47:13] INFO     ToolkitTask 038e687684c04ae2b83467221ca9f6c4                                                                                               
                             Output: The result of the expression \(83 - 10 \times 2 + \frac{4}{2}\) is 65.                                                             
Input a calculation like 5 + 3 * 2: exit
bye!

As you can see, it doesn’t just give the calculation's output; it is also interactive. It allows users to see the process of calculating the arithmetic expression. This transparency enhances the user experience by enabling users to understand how the final result is obtained.

Deploying Your Griptape Application

While we won’t be deploying this application, you can follow the instructions provided in the Griptape Cloud documentation. Griptape Cloud offers a component, Structures, for deploying applications whether it uses the Griptape Framework or not.

It also enables developers to build RAG pipelines by connecting to Griptape’s Data Sources for ingestion. To deploy your application, you can also start by creating an account and integrating with GitHub.

For more detailed steps on how to deploy a Griptape application, you can refer to the deployment guide in Griptape's Cloud documentation.

Summary

Building and deploying an AI application using Griptape shows how easily you can integrate LLM tools into your project. From handling user input to interacting with LLMs, Griptape simplifies the development process of developing an AI Application with its framework.

This article only focused on Griptape’s entire structure and how Griptape can be used to develop interactive AI applications. If you want to learn more about Griptape’s other offerings, I recommend checking out their official website.

Lastly, please do well to give Griptape a Star on GitHub. 😃

Star Griptape on GitHub 🌟

Thank you for reading this article. I look forward to hearing what you think about Griptape in the comment section! 👋

Forem: Griptape AI

What the Heck Are Hybrid Knowledge Bases? (And Why They Matter for LLM Apps)

🧠 So... What Is a Hybrid Knowledge Base?

🛠️ Example Use Case: Candidate Search

💡 Why It Matters

Read more

🙋‍♂️ What Would You Build?

Improving the dev experience for building apps that integrate up-to-date and private data with large language models

Announcing Griptape AI Framework 1.5

Griptape vs. LangChain, CrewAI, and LlamaIndex: Which AI Framework Performs Best?

TL;DR

Introduction

Overview of Griptape Framework

Give Griptape a Star on GitHub 🙏

Overview of LangChain

Overview of CrewAI

Overview of LlamaIndex

Understanding The Frameworks

Griptape Framework

Architecture

Key Features of Griptape Framework

LangChain

Architecture

Key Features of LangChain

LlamaIndex

Architecture

Key Features of LlamaIndex

CrewAI Framework

Architecture

Key Features of CrewAI Framework

Metrics for Comparison

Scalability

Performance

Code Complexity

Summary

References

Griptape: OSS Platform for Building AI Apps

TL;DR 🧏🏽

Introduction to Griptape

Griptape Framework

Griptape Cloud

Key Feature of Griptape

Give Griptape a Star on GitHub 🙏

Developing an AI Application Using Griptape and an LLM 🧙‍♀️

Deploying Your Griptape Application

Summary

References /Useful links ⛓️