Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/griptape-ai/griptape
Modular Python framework for AI agents and workflows with chain-of-thought reasoning, tools, and memory.
https://github.com/griptape-ai/griptape
ai anthropic claude gpt huggingface llm openai python
Last synced: 2 months ago
JSON representation
Modular Python framework for AI agents and workflows with chain-of-thought reasoning, tools, and memory.
- Host: GitHub
- URL: https://github.com/griptape-ai/griptape
- Owner: griptape-ai
- License: apache-2.0
- Created: 2023-01-14T18:02:16.000Z (over 1 year ago)
- Default Branch: dev
- Last Pushed: 2024-04-19T15:47:05.000Z (2 months ago)
- Last Synced: 2024-04-19T22:01:09.681Z (2 months ago)
- Topics: ai, anthropic, claude, gpt, huggingface, llm, openai, python
- Language: Python
- Homepage: https://www.griptape.ai
- Size: 8.52 MB
- Stars: 1,566
- Watchers: 24
- Forks: 106
- Open Issues: 71
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Lists
- awesome-langchain - Griptape - ai/griptape?style=social) (Other LLM Frameworks / Videos Playlists)
- awesome-list - griptape-ai/griptape - Modular Python framework for AI agents and workflows with chain-of-thought reasoning, tools, and memory. (Python)
- awesome-stars - griptape - of-thought reasoning, tools, and memory. Griptape is an enterprise grade alternative to LangChain. | griptape-ai | 1407 | (Python)
- awesome-langchain-zh - Griptape - ai/griptape?style=social):Python 框架，用于具有链式思维推理、外部工具和记忆的 AI 工作流和管道。 (其他LLM框架 / 文章)
README
[](https://pypi.python.org/pypi/griptape)
[](https://github.com/griptape-ai/griptape/actions/workflows/unit-tests.yml)
[](https://griptape.readthedocs.io/)
[](https://microsoft.github.io/pyright/)
[](https://github.com/psf/black)
[](https://discord.gg/gnWRz88eym)
Griptape is a modular Python framework for building AI-powered applications that securely connect to your enterprise data and APIs. It offers developers the ability to maintain control and flexibility at every step.
## 🛠️ Core Components
### 🏗️ Structures
- 🤖 **Agents** consist of a single Task.
- 🔄 **Pipelines** organize a sequence of Tasks so that the output from one Task may flow into the next.
- 🌐 **Workflows** configure Tasks to operate in parallel.
### 📝 Tasks
Tasks are the core building blocks within Structures, enabling interaction with Engines, Tools, and other Griptape components.
### 🔧 Tools
Tools provide capabilities for LLMs to interact with data and services. Griptape includes a variety of built-in Tools, and makes it easy to create custom Tools.
### 🧠 Memory
- 💬 **Conversation Memory** enables LLMs to retain and retrieve information across interactions.
- 🗃️ **Task Memory** keeps large or sensitive Task outputs off the prompt that is sent to the LLM.
- 📊 **Meta Memory** enables passing in additional metadata to the LLM, enhancing the context and relevance of the interaction.
### 🚗 Drivers
Drivers facilitate interactions with external resources and services:
- 🔢 **Prompt and Embedding Drivers** generate vector embeddings from textual inputs.
- 💾 **Vector Store Drivers** manage the storage and retrieval of embeddings.
- 🎨 **Image Generation Drivers** create images from text descriptions.
- 🔎 **Image Query Drivers** query images from text queries.
- 💼 **SQL Drivers** interact with SQL databases.
- 🌐 **Web Scraper Drivers** extract information from web pages.
- 🧠 **Conversation Memory Drivers** manage the storage and retrieval of conversational data.
### 🚂 Engines
Engines wrap Drivers and provide use-case-specific functionality:
- 📊 **Query Engines** execute Retrieval Augmented Generation (RAG) queries.
- 🛠️ **Extraction Engines** extract JSON or CSV data from unstructured text.
- 📝 **Summary Engines** generate summaries from textual content.
- 🖼️ **Image Generation Engines** generate images from textual descriptions.
- 🔎 **Image Query Engines** query images based on textual prompts.
### 📦 Additional Components
- 📐 **Rulesets** steer LLM behavior with minimal prompt engineering.
- 🔄 **Loaders** load data from various sources.
- 🏺 **Artifacts** allow for passing data of different types between Griptape components.
- ✂️ **Chunkers** segment texts into manageable pieces for diverse text types.
- 🔢 **Tokenizers** count the number of tokens in a text to not exceed LLM token limits.
## Documentation
Please refer to [Griptape Docs](https://docs.griptape.ai/) for:
- Getting started guides.
- Core concepts and design overviews.
- Examples.
- Contribution guidelines.
Please check out [Griptape Trade School](https://learn.griptape.ai/) for free online courses.
## Quick Start
First, install **griptape**:
```
pip install "griptape[all]" -U
```
Second, configure an OpenAI client by [getting an API key](https://platform.openai.com/account/api-keys) and adding it to your environment as `OPENAI_API_KEY`. By default, Griptape uses [OpenAI Chat Completions API](https://platform.openai.com/docs/guides/gpt/chat-completions-api) to execute LLM prompts.
With Griptape, you can create Structures, such as Agents, Pipelines, and Workflows, composed of different types of Tasks. Let's build a simple creative Agent that dynamically uses three tools and moves the data around in Task Memory.
```python
from griptape.structures import Agent
from griptape.tools import WebScraper, FileManager, TaskMemoryClient
agent = Agent(
input_template="Load {{ args[0] }}, summarize it, and store it in a file called {{ args[1] }}.",
tools=[
WebScraper(),
FileManager(),
TaskMemoryClient(off_prompt=True)
]
)
agent.run("https://griptape.ai", "griptape.txt")
```
And here is the output:
```
[04/02/24 13:51:09] INFO ToolkitTask 85700ec1b0594e1a9502c0efe7da6ef4
Input: Load https://griptape.ai, summarize it, and store it in a file called griptape.txt.
[04/02/24 13:51:15] INFO Subtask db6a3e7cb2f549128c358149d340f91c
Thought: First, I need to load the content of the website using the WebScraper action. Then, I will use the TaskMemoryClient action to
summarize the content. Finally, I will save the summarized content to a file using the FileManager action.
Actions: [
{
"name": "WebScraper",
"path": "get_content",
"input": {
"values": {
"url": "https://griptape.ai"
}
},
"tag": "load_website_content"
}
]
[04/02/24 13:51:16] INFO Subtask db6a3e7cb2f549128c358149d340f91c
Response: Output of "WebScraper.get_content" was stored in memory with memory_name "TaskMemory" and artifact_namespace
"752b38bb86da4baabdbd9f444eb4a0d1"
[04/02/24 13:51:19] INFO Subtask c3edba87ebf845d4b85e3a791f8fde8d
Thought: Now that the website content is loaded into memory, I need to summarize it using the TaskMemoryClient action.
Actions: [{"tag": "summarize_content", "name": "TaskMemoryClient", "path": "summarize", "input": {"values": {"memory_name": "TaskMemory",
"artifact_namespace": "752b38bb86da4baabdbd9f444eb4a0d1"}}}]
[04/02/24 13:51:25] INFO Subtask c3edba87ebf845d4b85e3a791f8fde8d
Response: Output of "TaskMemoryClient.summarize" was stored in memory with memory_name "TaskMemory" and artifact_namespace
"c4f131c201f147dcab07be3925b46294"
[04/02/24 13:51:33] INFO Subtask 06fe01ca64a744b38a8c08eb152aaacb
Thought: Now that the content has been summarized and stored in memory, I need to save this summarized content to a file named 'griptape.txt'
using the FileManager action.
Actions: [{"tag": "save_summarized_content", "name": "FileManager", "path": "save_memory_artifacts_to_disk", "input": {"values": {"dir_name":
".", "file_name": "griptape.txt", "memory_name": "TaskMemory", "artifact_namespace": "c4f131c201f147dcab07be3925b46294"}}}]
INFO Subtask 06fe01ca64a744b38a8c08eb152aaacb
Response: saved successfully
[04/02/24 13:51:35] INFO ToolkitTask 85700ec1b0594e1a9502c0efe7da6ef4
Output: The summarized content of the website https://griptape.ai has been successfully saved to a file named 'griptape.txt'.
```
During the run, the Griptape Agent loaded a webpage with a **Tool**, stored its full content in **Task Memory**, queried it to answer the original question, and finally saved the answer to a file.
The important thing to note here is that no matter how big the webpage is it can never blow up the prompt token limit because the full content of the page never goes back to the LLM. Additionally, no data from the subsequent subtasks were returned back to the prompt either. So, how does it work?
All Tools have the `off_prompt` property enabled be default. Disabling it (`off_prompt=False`) will force the framework to return all tool outputs directly to the LLM prompt. `TaskMemoryClient` requires the user to set this property explicitly for usability reasons. In the above example, we set `off_prompt` to `True`, which means that the LLM can never see the data it manipulates, but can send it to other Tools.
[Check out our docs](https://docs.griptape.ai/latest/griptape-framework/drivers/prompt-drivers/) to learn more about how to use Griptape with other LLM providers like Anthropic, Claude, Hugging Face, and Azure.
## Versioning
Griptape is in constant development and its APIs and documentation are subject to change. Until we stabilize the API and release version 1.0.0, we will use minor versions (i.e., x.Y.z) to introduce features and breaking features, and patch versions (i.e., x.y.Z) for bug fixes.
## Contributing
Thank you for considering contributing to Griptape! Before you start, please read the following guidelines.
### Submitting Issues
If you have identified a bug, want to propose a new feature, or have a question, please submit an issue through our public [issue tracker](https://github.com/griptape-ai/griptape/issues). Before submitting a new issue, please check the existing issues to ensure it hasn't been reported or discussed before.
### New Griptape Tools
Griptape's extensibility allows anyone to develop and distribute tools independently. With rare exceptions for Tools providing broadly applicable functionality, new Griptape Tools should be managed as their own projects and not submitted to the core framework. Pull requests for new tools (unless addressing an [existing issue](https://github.com/griptape-ai/griptape/issues)) will be closed.
The [Griptape Tool Template](https://github.com/griptape-ai/tool-template) provides the recommended structure, step-by-step instructions, basic automation, and usage examples for new Tools. In the Template, select **Use this template** then **Create a new repository** to begin a new Tool project.
### Submitting Pull Requests
We welcome and encourage pull requests. To streamline the process, please follow these guidelines:
1. **Existing Issues:** Please submit pull requests only for existing issues. If you want to work on new functionality or fix a bug that hasn't been addressed yet, please first submit an issue. This allows the Griptape team to internally process the request and provide a public response.
2. **Branch:** Submit all pull requests to the `dev` branch. This helps us manage changes and integrate them smoothly.
3. **Unit Tests:** Ensure that your pull request passes all existing unit tests. Additionally, if you are introducing new code, please include new unit tests to validate its functionality.
4. **Documentation:** Every pull request must include updates to documentation or explicitly explain why a documentation update is not required. Documentation is crucial for maintaining a comprehensive and user-friendly project.
5. **Code Style:** Griptape uses [Black](https://github.com/ambv/black) to enforce style guidelines. You can ensure that your code is formatted accordingly and will pass formatting checks using `pre-commit`. See [Tools](#tools) for information on how to configure this and other dev tools.
### Tools
Install dev dependencies with Poetry:
```shell
poetry install --all-extras --with dev --with test
```
Configure pre-commit to ensure that your code is formatted correctly and passes all checks:
```shell
poetry run pre-commit install
```
## License
Griptape is available under the Apache 2.0 License.