OpenRouter on Producthunt daily

elysia

Fri, 05 Sep 2025 15:28:11 +0800

weaviate/elysia

Elysia: Agentic Framework Powered by Decision Trees

⚠️ Elysia is in beta!

If you encounter any issues, please open an issue on GitHub.

Elysia is an agentic platform designed to use tools in a decision tree. A decision agent decides which tools to use dynamically based on its environment and context. You can use custom tools or use the pre-built tools designed to retrieve your data in a Weaviate cluster.

Read the docs!

Installation is as simple as:

`1`	`pip install elysia-ai`

Get started (App)

Run the app via

`1`	`elysia start`

Then navigate to the settings page, add your required API keys, Weaviate cloud cluster details and specify your models.

Don’t forget to check out the Github Repository for the Frontend!

Alternatively, we have created a demo version of Elysia (rate-limited, fixed datasets) to experiment with. Find it at: https://elysia.weaviate.io/

Get Started (Python)

To use Elysia, you need to either set up your models and API keys in your .env file, or specify them in the config. See the setup page to get started.

Elysia can be used very simply:

from elysia import tool, Tree

tree = Tree()

@tool(tree=tree)
async def add(x: int, y: int) -> int:
    return x + y

tree("What is the sum of 9009 and 6006?")

Elysia is pre-configured to be capable of connecting to and interacting with your Weaviate clusters!

import elysia
tree = elysia.Tree()
response, objects = tree(
    "What are the 10 most expensive items in the Ecommerce collection?",
    collection_names = ["Ecommerce"]
)

This will use the built-in open source query tool or aggregate tool to interact with your Weaviate collections. To get started connecting to Weaviate, see the setting up page in the docs.

Installation (bash) (Linux/MacOS)

PyPi (Recommended)

Elysia requires Python 3.12:

Optionally create a virtual environment via

1
2

python3.12 -m venv .venv
source .venv/bin/activate

Then simply run

`1`	`pip install elysia-ai`

to install straight away!

GitHub

To get the latest development version, you can clone the github repo by running

`1`	`git clone https://github.com/weaviate/elysia`

move to the working directory via

`1`	`cd elysia`

Create a virtual environment with Python (version 3.10 - 3.12)

1
2

python3.12 -m venv .venv
source .venv/bin/activate

and then install Elysia via pip

`1`	`pip install -e .`

Done! You can now use the Elysia python package

Configuring Settings

To use Elysia with Weaviate, i.e. for agentic searching and retrieval, you need a Weaviate cluster api key and URL. This can be specific in the app directly, or by creating a .env file with

1
2

WCD_URL=...
WCD_API_KEY=...

Elysia will automatically detect these when running locally, and this will be the default Weaviate cluster for all users logging into the Elysia app. But these can be configured on a user-by-user basis through the config.

Whichever vectoriser you use for your Weaviate collection you will need to specify your corresponding API key, e.g.

`1`	`OPENAI_API_KEY=...`

These will automatically be added to the headers for the Weaviate client.

Same for whichever model you choose for the LLM in Elysia, so if you are using GPT-4o, for example, specify an OPENAI_API_KEY.

Elysia’s recommended config is to use OpenRouter to give easy access to a variety of models. So this requires

`1`	`OPENROUTER_API_KEY=...`

FAQ

How do I use Elysia with my own data?

You can connect to your own Weaviate cloud cluster, which will automatically identify any collections that exist in the cluster.

Collections require being preprocessed for Elysia. In the app, you just click the ‘analyze’ button in the Data tab. In Python you can do:

1
2
3

from elysia.preprocessing.collection import preprocess

preprocess(collection_names=["YourCollectionName"])

Can I use a locally running version of Weaviate such as with Docker?

Locally running versions of Weaviate are currently not implemented in the current version of the app but this is planned for a future release. Stay tuned!

How do I clear all my Elysia data?

Everything Elysia doesn’t store locally will be a collection in your Weaviate cluster. You can delete any collections that start with ELYSIA_ to reset all your Elysia data.

For example, in Python:

from elysia.util.client import ClientManager()
with ClientManager().connect_to_client() as client:
    for collection_name in client.collections.list_all():
        if collection_name.startswith("ELYSIA_"):
            client.collections.delete(collection_name)

Can I contribute to Elysia?

Elysia is fully open source, so yes of course you can! Clone and create a new branch of Elysia via

1
2

git clone https://github.com/weaviate/elysia
git checkout -b <branch_name>

Make your changes, push them to your branch, go to GitHub and submit a pull request.

Where is the best place I can start contributing?

There are no ‘huge’ new features we are planning for Elysia (for the moment). You could start with creating a new tool, or multiple new tools to create a custom workflow for something specific. Look for pain points you experience from your user journey and find what exactly is causing these. Then try to fix them or create an alternative way of doing things!

claude-task-master

Tue, 10 Jun 2025 15:29:20 +0800

eyaltoledano/claude-task-master

Task Master

By @eyaltoledano, @RalphEcom & @jasonzhou1993

A task management system for AI-driven development with Claude, designed to work seamlessly with Cursor AI.

Documentation

For more detailed information, check out the documentation in the docs directory:

Configuration Guide - Set up environment variables and customize Task Master
Tutorial - Step-by-step guide to getting started with Task Master
Command Reference - Complete list of all available commands
Task Structure - Understanding the task format and features
Example Interactions - Common Cursor AI interaction examples
Migration Guide - Guide to migrating to the new project structure

Quick Install for Cursor 1.0+ (One-Click)

Note: After clicking the install button, you’ll still need to add your API keys to the configuration. The button installs the MCP server with placeholder keys that you’ll need to replace with your actual API keys.

Requirements

Taskmaster utilizes AI across several commands, and those require a separate API key. You can use a variety of models from different AI providers provided you add your API keys. For example, if you want to use Claude 3.7, you’ll need an Anthropic API key.

You can define 3 types of models to be used: the main model, the research model, and the fallback model (in case either the main or research fail). Whatever model you use, its provider API key must be present in either mcp.json or .env.

At least one (1) of the following is required:

Anthropic API key (Claude API)
OpenAI API key
Google Gemini API key
Perplexity API key (for research model)
xAI API Key (for research or main model)
OpenRouter API Key (for research or main model)

Using the research model is optional but highly recommended. You will need at least ONE API key. Adding all API keys enables you to seamlessly switch between model providers at will.

Quick Start

Option 1: MCP (Recommended)

MCP (Model Control Protocol) lets you run Task Master directly from your editor.

1. Add your MCP config at the following path depending on your editor

Editor	Scope	Linux/macOS Path	Windows Path	Key
Cursor	Global	`~/.cursor/mcp.json`	`%USERPROFILE%\.cursor\mcp.json`	`mcpServers`
	Project	`<project_folder>/.cursor/mcp.json`	`<project_folder>\.cursor\mcp.json`	`mcpServers`
Windsurf	Global	`~/.codeium/windsurf/mcp_config.json`	`%USERPROFILE%\.codeium\windsurf\mcp_config.json`	`mcpServers`
VS Code	Project	`<project_folder>/.vscode/mcp.json`	`<project_folder>\.vscode\mcp.json`	`servers`

Manual Configuration

Cursor & Windsurf (`mcpServers`)

{
  "mcpServers": {
    "taskmaster-ai": {
      "command": "npx",
      "args": ["-y", "--package=task-master-ai", "task-master-ai"],
      "env": {
        "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
        "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
        "OPENAI_API_KEY": "YOUR_OPENAI_KEY_HERE",
        "GOOGLE_API_KEY": "YOUR_GOOGLE_KEY_HERE",
        "MISTRAL_API_KEY": "YOUR_MISTRAL_KEY_HERE",
        "OPENROUTER_API_KEY": "YOUR_OPENROUTER_KEY_HERE",
        "XAI_API_KEY": "YOUR_XAI_KEY_HERE",
        "AZURE_OPENAI_API_KEY": "YOUR_AZURE_KEY_HERE",
        "OLLAMA_API_KEY": "YOUR_OLLAMA_API_KEY_HERE"
      }
    }
  }
}

🔑 Replace YOUR_…_KEY_HERE with your real API keys. You can remove keys you don’t use.

VS Code (`servers` + `type`)

{
  "servers": {
    "taskmaster-ai": {
      "command": "npx",
      "args": ["-y", "--package=task-master-ai", "task-master-ai"],
      "env": {
        "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
        "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
        "OPENAI_API_KEY": "YOUR_OPENAI_KEY_HERE",
        "GOOGLE_API_KEY": "YOUR_GOOGLE_KEY_HERE",
        "MISTRAL_API_KEY": "YOUR_MISTRAL_KEY_HERE",
        "OPENROUTER_API_KEY": "YOUR_OPENROUTER_KEY_HERE",
        "XAI_API_KEY": "YOUR_XAI_KEY_HERE",
        "AZURE_OPENAI_API_KEY": "YOUR_AZURE_KEY_HERE"
      },
      "type": "stdio"
    }
  }
}

🔑 Replace YOUR_…_KEY_HERE with your real API keys. You can remove keys you don’t use.

2. (Cursor-only) Enable Taskmaster MCP

Open Cursor Settings (Ctrl+Shift+J) ➡ Click on MCP tab on the left ➡ Enable task-master-ai with the toggle

3. (Optional) Configure the models you want to use

In your editor’s AI chat pane, say:

`1`	`Change the main, research and fallback models to <model_name>, <model_name> and <model_name> respectively.`

Table of available models

4. Initialize Task Master

In your editor’s AI chat pane, say:

`1`	`Initialize taskmaster-ai in my project`

5. Make sure you have a PRD (Recommended)

For new projects: Create your PRD at .taskmaster/docs/prd.txt
For existing projects: You can use scripts/prd.txt or migrate with task-master migrate

An example PRD template is available after initialization in .taskmaster/templates/example_prd.txt.

[!NOTE] While a PRD is recommended for complex projects, you can always create individual tasks by asking “Can you help me implement [description of what you want to do]?” in chat.

Always start with a detailed PRD.

The more detailed your PRD, the better the generated tasks will be.

6. Common Commands

Use your AI assistant to:

Parse requirements: Can you parse my PRD at scripts/prd.txt?
Plan next step: What's the next task I should work on?
Implement a task: Can you help me implement task 3?
Expand a task: Can you help me expand task 4?

More examples on how to use Task Master in chat

Option 2: Using Command Line

Installation

# Install globally
npm install -g task-master-ai

# OR install locally within your project
npm install task-master-ai

Initialize a new project

# If installed globally
task-master init

# If installed locally
npx task-master init

This will prompt you for project details and set up a new project with the necessary files and structure.

Common Commands

# Initialize a new project
task-master init

# Parse a PRD and generate tasks
task-master parse-prd your-prd.txt

# List all tasks
task-master list

# Show the next task to work on
task-master next

# Generate task files
task-master generate

Troubleshooting

If `task-master init` doesn’t respond

Try running it with Node directly:

`1`	`node node_modules/claude-task-master/scripts/init.js`

Or clone the repository and run:

1
2
3

git clone https://github.com/eyaltoledano/claude-task-master.git
cd claude-task-master
node scripts/init.js

Contributors

Star History

Licensing

Task Master is licensed under the MIT License with Commons Clause. This means you can:

✅ Allowed:

Use Task Master for any purpose (personal, commercial, academic)
Modify the code
Distribute copies
Create and sell products built using Task Master

❌ Not Allowed:

Sell Task Master itself
Offer Task Master as a hosted service
Create competing products based on Task Master

See the LICENSE file for the complete license text and licensing details for more information.