Summarization on Producthunt daily

open_deep_research

Tue, 22 Jul 2025 15:33:16 +0800

langchain-ai/open_deep_research

Open Deep Research

Deep research has broken out as one of the most popular agent applications. This is a simple, configurable, fully open source deep research agent that works across many model providers, search tools, and MCP servers.

Read more in our blog
See our video for a quick overview

🚀 Quickstart

Clone the repository and activate a virtual environment:

git clone https://github.com/langchain-ai/open_deep_research.git
cd open_deep_research
uv venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

Install dependencies:

`1`	`uv pip install -r pyproject.toml`

Set up your .env file to customize the environment variables (for model selection, search tools, and other configuration settings):

`1`	`cp .env.example .env`

Launch the assistant with the LangGraph server locally to open LangGraph Studio in your browser:

1
2

# Install dependencies and start the LangGraph server
uvx --refresh --from "langgraph-cli[inmem]" --with-editable . --python 3.11 langgraph dev --allow-blocking

Use this to open the Studio UI:

1
2
3

- 🚀 API: http://127.0.0.1:2024
- 🎨 Studio UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
- 📚 API Docs: http://127.0.0.1:2024/docs

Ask a question in the messages input field and click Submit.

Configurations

Open Deep Research offers extensive configuration options to customize the research process and model behavior. All configurations can be set via the web UI, environment variables, or by modifying the configuration directly.

General Settings

Max Structured Output Retries (default: 3): Maximum number of retries for structured output calls from models when parsing fails
Allow Clarification (default: true): Whether to allow the researcher to ask clarifying questions before starting research
Max Concurrent Research Units (default: 5): Maximum number of research units to run concurrently using sub-agents. Higher values enable faster research but may hit rate limits

Research Configuration

Search API (default: Tavily): Choose from Tavily (works with all models), OpenAI Native Web Search, Anthropic Native Web Search, or None
Max Researcher Iterations (default: 3): Number of times the Research Supervisor will reflect on research and ask follow-up questions
Max React Tool Calls (default: 5): Maximum number of tool calling iterations in a single researcher step

Models

Open Deep Research uses multiple specialized models for different research tasks:

Summarization Model (default: openai:gpt-4.1-nano): Summarizes research results from search APIs
Research Model (default: openai:gpt-4.1): Conducts research and analysis
Compression Model (default: openai:gpt-4.1-mini): Compresses research findings from sub-agents
Final Report Model (default: openai:gpt-4.1): Writes the final comprehensive report

All models are configured using init_chat_model() API which supports providers like OpenAI, Anthropic, Google Vertex AI, and others.

Important Model Requirements:

Structured Outputs: All models must support structured outputs. Check support here.
Search API Compatibility: Research and Compression models must support your selected search API:
- Anthropic search requires Anthropic models with web search capability
- OpenAI search requires OpenAI models with web search capability
- Tavily works with all models
Tool Calling: All models must support tool calling functionality
Special Configurations:
- For OpenRouter: Follow this guide
- For local models via Ollama: See setup instructions

Example MCP (Model Context Protocol) Servers

Open Deep Research supports MCP servers to extend research capabilities.

Local MCP Servers

Filesystem MCP Server provides secure file system operations with robust access control:

Read, write, and manage files and directories
Perform operations like reading file contents, creating directories, moving files, and searching
Restrict operations to predefined directories for security
Support for both command-line configuration and dynamic MCP roots

Example usage:

`1`	`mcp-server-filesystem /path/to/allowed/dir1 /path/to/allowed/dir2`

Remote MCP Servers

Remote MCP servers enable distributed agent coordination and support streamable HTTP requests. Unlike local servers, they can be multi-tenant and require more complex authentication.

Arcade MCP Server Example:

{
  "url": "https://api.arcade.dev/v1/mcps/ms_0ujssxh0cECutqzMgbtXSGnjorm",
  "tools": ["Search_SearchHotels", "Search_SearchOneWayFlights", "Search_SearchRoundtripFlights"]
}

Remote servers can be configured as authenticated or unauthenticated and support JWT-based authentication through OAuth endpoints.

Evaluation

A comprehensive batch evaluation system designed for detailed analysis and comparative studies.

Features:

Multi-dimensional Scoring: Specialized evaluators with 0-1 scale ratings
Dataset-driven Evaluation: Batch processing across multiple test cases

Usage:

1
2

# Run comprehensive evaluation on LangSmith datasets
python tests/run_evaluate.py

Key Files:

tests/run_evaluate.py: Main evaluation script
tests/evaluators.py: Specialized evaluator functions
tests/prompts.py: Evaluation prompts for each dimension

Deployments and Usages

LangGraph Studio

Follow the quickstart to start LangGraph server locally and test the agent out on LangGraph Studio.

Hosted deployment

You can easily deploy to LangGraph Platform.

Open Agent Platform

Open Agent Platform (OAP) is a UI from which non-technical users can build and configure their own agents. OAP is great for allowing users to configure the Deep Researcher with different MCP tools and search APIs that are best suited to their needs and the problems that they want to solve.

We’ve deployed Open Deep Research to our public demo instance of OAP. All you need to do is add your API Keys, and you can test out the Deep Researcher for yourself! Try it out here

You can also deploy your own instance of OAP, and make your own custom agents (like Deep Researcher) available on it to your users.

Updates 🔥

Legacy Implementations 🏛️

The src/legacy/ folder contains two earlier implementations that provide alternative approaches to automated research:

1. Workflow Implementation (`legacy/graph.py`)

Plan-and-Execute: Structured workflow with human-in-the-loop planning
Sequential Processing: Creates sections one by one with reflection
Interactive Control: Allows feedback and approval of report plans
Quality Focused: Emphasizes accuracy through iterative refinement

2. Multi-Agent Implementation (`legacy/multi_agent.py`)

Supervisor-Researcher Architecture: Coordinated multi-agent system
Parallel Processing: Multiple researchers work simultaneously
Speed Optimized: Faster report generation through concurrency
MCP Support: Extensive Model Context Protocol integration

See src/legacy/legacy.md for detailed documentation, configuration options, and usage examples for both legacy implementations.

anthropic-cookbook

Sat, 21 Jun 2025 15:28:31 +0800

anthropics/anthropic-cookbook

Anthropic Cookbook

The Anthropic Cookbook provides code and guides designed to help developers build with Claude, offering copy-able code snippets that you can easily integrate into your own projects.

Prerequisites

To make the most of the examples in this cookbook, you’ll need an Anthropic API key (sign up for free here).

While the code examples are primarily written in Python, the concepts can be adapted to any programming language that supports interaction with the Anthropic API.

If you’re new to working with the Anthropic API, we recommend starting with our Anthropic API Fundamentals course to get a solid foundation.

Explore Further

Looking for more resources to enhance your experience with Claude and AI assistants? Check out these helpful links:

Contributing

The Anthropic Cookbook thrives on the contributions of the developer community. We value your input, whether it’s submitting an idea, fixing a typo, adding a new guide, or improving an existing one. By contributing, you help make this resource even more valuable for everyone.

To avoid duplication of efforts, please review the existing issues and pull requests before contributing.

If you have ideas for new examples or guides, share them on the issues page.

Table of recipes

Skills

Classification: Explore techniques for text and data classification using Claude.
Retrieval Augmented Generation: Learn how to enhance Claude’s responses with external knowledge.
Summarization: Discover techniques for effective text summarization with Claude.

Tool Use and Integration

Tool use: Learn how to integrate Claude with external tools and functions to extend its capabilities.

Third-Party Integrations

Retrieval augmented generation: Supplement Claude’s knowledge with external data sources.
Embeddings with Voyage AI

Multimodal Capabilities

Vision with Claude:
Generate images with Claude: Use Claude with Stable Diffusion for image generation.

Advanced Techniques

Sub-agents: Learn how to use Haiku as a sub-agent in combination with Opus.
Upload PDFs to Claude: Parse and pass PDFs as text to Claude.
Automated evaluations: Use Claude to automate the prompt evaluation process.
Enable JSON mode: Ensure consistent JSON output from Claude.
Create a moderation filter: Use Claude to create a content moderation filter for your application.
Prompt caching: Learn techniques for efficient prompt caching with Claude.

Additional Resources

Anthropic on AWS: Explore examples and solutions for using Claude on AWS infrastructure.
AWS Samples: A collection of code samples from AWS which can be adapted for use with Claude. Note that some samples may require modification to work optimally with Claude.

meeting-minutes

Thu, 17 Apr 2025 15:30:04 +0800

Zackriya-Solutions/meeting-minutes

Meetily - AI-Powered Meeting Assistant

Open source Ai Assistant for taking meeting notes

Website • Author • Discord Channel

An AI-Powered Meeting Assistant that captures live meeting audio, transcribes it in real-time, and generates summaries while ensuring user privacy. Perfect for teams who want to focus on discussions while automatically capturing and organizing meeting content without the need for external servers or complex infrastructure.

View full Demo Video

Overview

An AI-powered meeting assistant that captures live meeting audio, transcribes it in real-time, and generates summaries while ensuring user privacy. Perfect for teams who want to focus on discussions while automatically capturing and organizing meeting content.

Why?

While there are many meeting transcription tools available, this solution stands out by offering:

Privacy First: All processing happens locally on your device
Cost Effective: Uses open-source AI models instead of expensive APIs
Flexible: Works offline, supports multiple meeting platforms
Customizable: Self-host and modify for your specific needs
Intelligent: Built-in knowledge graph for semantic search across meetings

Features

✅ Modern, responsive UI with real-time updates

✅ Real-time audio capture (microphone + system audio)

✅ Live transcription using Whisper.cpp

🚧 Speaker diarization

✅ Local processing for privacy

✅ Packaged the app for macOS and Windows

🚧 Export to Markdown/PDF

Note: We have a Rust-based implementation that explores better performance and native integration. It currently implements:

✅ Real-time audio capture from both microphone and system audio

✅ Live transcription using locally-running Whisper

✅ Speaker diarization

✅ Rich text editor for notes

We are currently working on:

✅ Export to Markdown/PDF

✅ Export to HTML

Release 0.0.3

A new release is available!

Please check out the release here.

What’s New

Windows Support: Fixed audio capture issues on Windows
Improved Error Handling: Better error handling and logging for audio devices
Enhanced Device Detection: More robust audio device detection across platforms
Windows Installers: Added both .exe and .msi installers for Windows
Transcription quality is improved
Bug fixes and improvements for frontend
Better backend app build process
Improved documentation

What would be next?

Database connection to save meeting minutes
Improve summarization quality for smaller LLM models
Add download options for meeting transcriptions
Add download option for summary

Known issues

Smaller LLMs can hallucinate, making summarization quality poor; Please use model above 32B parameter size
Backend build process requires CMake, C++ compiler, etc. Making it harder to build
Backend build process requires Python 3.10 or newer
Frontend build process requires Node.js

LLM Integration

The backend supports multiple LLM providers through a unified interface. Current implementations include:

Supported Providers

Anthropic (Claude models)
Groq (Llama3.2 90 B)
Ollama (Local models that supports function calling)

Configuration

Create .env file with your API keys:

# Required for Anthropic
ANTHROPIC_API_KEY=your_key_here  

# Required for Groq 
GROQ_API_KEY=your_key_here

System Architecture

Core Components

Audio Capture Service
- Real-time microphone/system audio capture
- Audio preprocessing pipeline
- Built with Rust (experimental) and Python
Transcription Engine
- Whisper.cpp for local transcription
- Supports multiple model sizes (tiny->large)
- GPU-accelerated processing
LLM Orchestrator
- Unified interface for multiple providers
- Automatic fallback handling
- Chunk processing with overlap
- Model configuration:
Data Services
- ChromaDB: Vector store for transcript embeddings
- SQLite: Process tracking and metadata storage
API Layer
- FastAPI endpoints:
  - POST /upload
  - POST /process
  - GET /summary/{id}
  - DELETE /summary/{id}

Deployment Architecture

Frontend: Tauri app + Next.js (packaged executables)
Backend: Python FastAPI:
- Transcript workers
- LLM inference

Prerequisites

Node.js 18+
Python 3.10+
FFmpeg
Rust 1.65+ (for experimental features)
Cmake 3.22+ (for building the frontend)
For Windows: Visual Studio Build Tools with C++ development workload

Setup Instructions

1. Frontend Setup

Run packaged version

Go to the releases page and download the latest version.

For Windows:

Download either the .exe installer or .msi package
Once the installer is downloaded, double-click the executable file to run it
Windows will ask if you want to run untrusted apps, click “More info” and choose “Run anyway”
Follow the installation wizard to complete the setup
The application will be installed and available on your desktop

For macOS:

Download the dmg_darwin_arch64.zip file
Extract the file
Double-click the .dmg file inside the extracted folder
Drag the application to your Applications folder
Execute the following command in terminal to remove the quarantine attribute:
1

xattr -c /Applications/meeting-minutes-frontend.app

Provide necessary permissions for audio capture and microphone access.

Dev run

# Navigate to frontend directory
cd frontend

# Give execute permissions to clean_build.sh
chmod +x clean_build.sh

# run clean_build.sh
./clean_build.sh

2. Backend Setup

# Clone the repository
git clone https://github.com/Zackriya-Solutions/meeting-minutes.git
cd meeting-minutes/backend

# Create and activate virtual environment
# On macOS/Linux:
python -m venv venv
source venv/bin/activate

# On Windows:
python -m venv venv
.\venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

# Add environment file with API keys
# On macOS/Linux:
echo -e "ANTHROPIC_API_KEY=your_api_key\nGROQ_API_KEY=your_api_key" | tee .env

# On Windows (PowerShell):
"ANTHROPIC_API_KEY=your_api_key`nGROQ_API_KEY=your_api_key" | Out-File -FilePath .env -Encoding utf8

# Configure environment variables for Groq
# On macOS/Linux:
export GROQ_API_KEY=your_groq_api_key

# On Windows (PowerShell):
$env:GROQ_API_KEY="your_groq_api_key"

# Build dependencies
# On macOS/Linux:
chmod +x build_whisper.sh
./build_whisper.sh

# On Windows:
.\build_whisper.bat

# Start backend servers
# On macOS/Linux:
./clean_start_backend.sh

# On Windows:
.\start_with_output.ps1

Development Guidelines

Follow the established project structure
Write tests for new features
Document API changes
Use type hints in Python code
Follow ESLint configuration for JavaScript/TypeScript

Contributing

Fork the repository
Create a feature branch
Submit a pull request

License

MIT License - Feel free to use this project for your own purposes.

Introducing Subscription

We are planning to add a subscription option so that you don’t have to run the backend on your own server. This will help you scale better and run the service 24/7. This is based on a few requests we received. If you are interested, please fill out the form here.

Last updated: March 3, 2025

Summarization on Producthunt daily

open_deep_research

langchain-ai/open_deep_research

Open Deep Research

🚀 Quickstart

Configurations

General Settings

Research Configuration

Models

Example MCP (Model Context Protocol) Servers

Local MCP Servers

Remote MCP Servers

Evaluation

Features:

Usage:

Key Files:

Deployments and Usages

LangGraph Studio

Hosted deployment

Open Agent Platform

Updates 🔥

Legacy Implementations 🏛️

1. Workflow Implementation (legacy/graph.py)

2. Multi-Agent Implementation (legacy/multi_agent.py)

anthropic-cookbook

anthropics/anthropic-cookbook

Anthropic Cookbook

Prerequisites

Explore Further

Contributing

Table of recipes

Skills

Tool Use and Integration

Third-Party Integrations

Multimodal Capabilities

Advanced Techniques

Additional Resources

meeting-minutes

Zackriya-Solutions/meeting-minutes

Meetily - AI-Powered Meeting Assistant

Open source Ai Assistant for taking meeting notes

Overview

Why?

Features

Release 0.0.3

What’s New

What would be next?

Known issues

LLM Integration

Supported Providers

Configuration

System Architecture

Core Components

Deployment Architecture

Prerequisites

Setup Instructions

1. Frontend Setup

Run packaged version

Dev run

2. Backend Setup

Development Guidelines

Contributing

License

Introducing Subscription

Star History

1. Workflow Implementation (`legacy/graph.py`)

2. Multi-Agent Implementation (`legacy/multi_agent.py`)