LangChain 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.

GenAI_Agents

Wed, 09 Jul 2025 15:32:24 +0800

NirDiamant/GenAI_Agents

🌟 Support This Project: Your sponsorship fuels innovation in GenAI agent development. Become a sponsor to help maintain and expand this valuable resource!

GenAI Agents: Comprehensive Repository for Development and Implementation 🚀

Welcome to one of the most extensive and dynamic collections of Generative AI (GenAI) agent tutorials and implementations available today. This repository serves as a comprehensive resource for learning, building, and sharing GenAI agents, ranging from simple conversational bots to complex, multi-agent systems.

📫 Stay Updated!

🚀
Cutting-edge
Updates

💡
Expert
Insights

🎯
Top 0.1%
Content

Join over 20,000 of AI enthusiasts getting unique cutting-edge insights and free tutorials! Plus, subscribers get exclusive early access and special 33% discounts to my book and the upcoming RAG Techniques course!

Introduction

Generative AI agents are at the forefront of artificial intelligence, revolutionizing the way we interact with and leverage AI technologies. This repository is designed to guide you through the development journey, from basic agent implementations to advanced, cutting-edge systems.

📚 Learn to Build Your First AI Agent

Your First AI Agent: Simpler Than You Think

This detailed blog post complements the repository by providing a complete A-Z walkthrough with in-depth explanations of core concepts, step-by-step implementation, and the theory behind AI agents. It's designed to be incredibly simple to follow while covering everything you need to know to build your first working agent from scratch.

💡 Plus: Subscribe to the newsletter for exclusive early access to tutorials and special discounts on upcoming courses and books!

Our goal is to provide a valuable resource for everyone - from beginners taking their first steps in AI to seasoned practitioners pushing the boundaries of what’s possible. By offering a range of examples from foundational to complex, we aim to facilitate learning, experimentation, and innovation in the rapidly evolving field of GenAI agents.

Furthermore, this repository serves as a platform for showcasing innovative agent creations. Whether you’ve developed a novel agent architecture or found an innovative application for existing techniques, we encourage you to share your work with the community.

🚀 Level up with my Agents Towards Production repository. It delivers horizontal, code-first tutorials that cover every tool and step in the lifecycle of building production-grade GenAI agents, guiding you from spark to scale with proven patterns and reusable blueprints for real-world launches, making it the smartest place to start if you’re serious about shipping agents to production.

📚 Dive into my comprehensive guide on RAG techniques to learn about integrating external knowledge into AI systems, enhancing their capabilities with up-to-date and relevant information retrieval.

🖋️ Explore my Prompt Engineering Techniques guide for an extensive collection of prompting strategies, from fundamental concepts to advanced methods, improving your ability to communicate effectively with AI language models.

A Community-Driven Knowledge Hub

This repository grows stronger with your contributions! Join our vibrant Discord community — the central hub for shaping and advancing this project together 🤝

GenAI Agents Discord Community

Whether you’re a novice eager to learn or an expert ready to share your knowledge, your insights can shape the future of GenAI agents. Join us to propose ideas, get feedback, and collaborate on innovative implementations. For contribution guidelines, please refer to our CONTRIBUTING.md file. Let’s advance GenAI agent technology together!

🔗 For discussions on GenAI, agents, or to explore knowledge-sharing opportunities, feel free to connect on LinkedIn.

Key Features

🎓 Learn to build GenAI agents from beginner to advanced levels
🧠 Explore a wide range of agent architectures and applications
📚 Step-by-step tutorials and comprehensive documentation
🛠️ Practical, ready-to-use agent implementations
🌟 Regular updates with the latest advancements in GenAI
🤝 Share your own agent creations with the community

GenAI Agent Implementations

Below is a comprehensive overview of our GenAI agent implementations, organized by category and functionality. Each implementation is designed to showcase different aspects of AI agent development, from basic conversational agents to complex multi-agent systems.

#	Category	Agent Name	Framework	Key Features
1	🌱 Beginner	Simple Conversational Agent	LangChain/PydanticAI	Context-aware conversations, history management
2	🌱 Beginner	Simple Question Answering	LangChain	Query understanding, concise answers
3	🌱 Beginner	Simple Data Analysis	LangChain/PydanticAI	Dataset interpretation, natural language queries
4	🔧 Framework	Introduction to LangGraph	LangGraph	Modular AI workflows, state management
5	🔧 Framework	Model Context Protocol (MCP)	MCP	AI-external resource integration
6	🎓 Educational	ATLAS: Academic Task System	LangGraph	Multi-agent academic planning, note-taking
7	🎓 Educational	Scientific Paper Agent	LangGraph	Literature review automation
8	🎓 Educational	Chiron - Feynman Learning	LangGraph	Adaptive learning, checkpoint system
9	💼 Business	Customer Support Agent	LangGraph	Query categorization, sentiment analysis
10	💼 Business	Essay Grading Agent	LangGraph	Automated grading, multiple criteria
11	💼 Business	Travel Planning Agent	LangGraph	Personalized itineraries
12	💼 Business	GenAI Career Assistant	LangGraph	Career guidance, learning paths
13	💼 Business	Project Manager Assistant	LangGraph	Task generation, risk assessment
14	💼 Business	Contract Analysis Assistant	LangGraph	Clause analysis, compliance checking
15	💼 Business	E2E Testing Agent	LangGraph	Test automation, browser control
16	🎨 Creative	GIF Animation Generator	LangGraph	Text-to-animation pipeline
17	🎨 Creative	TTS Poem Generator	LangGraph	Text classification, speech synthesis
18	🎨 Creative	Music Compositor	LangGraph	AI music composition
19	🎨 Creative	Content Intelligence	LangGraph	Multi-platform content generation
20	🎨 Creative	Business Meme Generator	LangGraph	Brand-aligned meme creation
21	🎨 Creative	Murder Mystery Game	LangGraph	Procedural story generation
22	📊 Analysis	Memory-Enhanced Conversational	LangChain	Short/long-term memory integration
23	📊 Analysis	Multi-Agent Collaboration	LangChain	Historical research, data analysis
24	📊 Analysis	Self-Improving Agent	LangChain	Learning from interactions
25	📊 Analysis	Task-Oriented Agent	LangChain	Text summarization, translation
26	📊 Analysis	Internet Search Agent	LangChain	Web research, summarization
27	📊 Analysis	Research Team - Autogen	AutoGen	Multi-agent research collaboration
28	📊 Analysis	Sales Call Analyzer	LangGraph	Audio transcription, NLP analysis
29	📊 Analysis	Weather Emergency System	LangGraph	Real-time data processing
30	📊 Analysis	Self-Healing Codebase	LangGraph	Error detection, automated fixes
31	📊 Analysis	DataScribe	LangGraph	Database exploration, query planning
32	📊 Analysis	Memory-Enhanced Email	LangGraph	Email triage, response generation
33	📰 News	News TL;DR	LangGraph	News summarization, API integration
34	📰 News	AInsight	LangGraph	AI/ML news aggregation
35	📰 News	Journalism Assistant	LangGraph	Fact-checking, bias detection
36	📰 News	Blog Writer	OpenAI Swarm	Collaborative content creation
37	📰 News	Podcast Generator	LangGraph	Content search, audio generation
38	🛍️ Shopping	ShopGenie	LangGraph	Product comparison, recommendations
39	🛍️ Shopping	Car Buyer Agent	LangGraph	Web scraping, decision support
40	🎯 Task Management	Taskifier	LangGraph	Work style analysis, task breakdown
41	🎯 Task Management	Grocery Management	CrewAI	Inventory tracking, recipe suggestions
42	🔍 QA	LangGraph Inspector	LangGraph	System testing, vulnerability detection
43	🔍 QA	EU Green Deal Bot	LangGraph	Regulatory compliance, FAQ system
44	🔍 QA	Systematic Review	LangGraph	Academic paper processing, draft generation
45	🌟 Advanced	Controllable RAG Agent	Custom	Complex question answering, deterministic graph

Explore our extensive list of GenAI agent implementations, sorted by categories:

🌱 Beginner-Friendly Agents

Simple Conversational Agent
- LangChain
- PydanticAI
Overview 🔎
A context-aware conversational AI maintains information across interactions, enabling more natural dialogues.

Implementation 🛠️
Integrates a language model, prompt template, and history manager to generate contextual responses and track conversation sessions.
Simple Question Answering Agent

Overview 🔎
Answering (QA) agent using LangChain and OpenAI’s language model understands user queries and provides relevant, concise answers.

Implementation 🛠️
Combines OpenAI’s GPT model, a prompt template, and an LLMChain to process user questions and generate AI-driven responses in a streamlined manner.
Simple Data Analysis Agent
- LangChain
- PydanticAI
Overview 🔎
An AI-powered data analysis agent interprets and answers questions about datasets using natural language, combining language models with data manipulation tools for intuitive data exploration.

Implementation 🛠️
Integrates a language model, data manipulation framework, and agent framework to process natural language queries and perform data analysis on a synthetic dataset, enabling accessible insights for non-technical users.

🔧 Framework Tutorial

Introduction to LangGraph: Building Modular AI Workflows

Overview 🔎
This tutorial introduces LangGraph, a powerful framework for creating modular, graph-based AI workflows. Learn how to leverage LangGraph to build more complex and flexible AI agents that can handle multi-step processes efficiently.

Implementation 🛠️
Step-by-step guide on using LangGraph to create a StateGraph workflow. The tutorial covers key concepts such as state management, node creation, and graph compilation. It demonstrates these principles by constructing a simple text analysis pipeline, serving as a foundation for more advanced agent architectures.

Additional Resources 📚
- Blog Post
Model Context Protocol (MCP): Seamless Integration of AI and External Resources

Overview 🔎
This tutorial introduces the Model Context Protocol (MCP), an open standard for connecting AI models with external data sources and tools. Learn how MCP serves as a universal bridge between GenAI agents and the wider digital ecosystem, enabling more capable and context-aware AI applications.

Implementation 🛠️
Provides a hands-on guide to implementing MCP servers and clients, demonstrating how to connect language models with external tools and data sources. The tutorial covers server setup, tool definition, and integration with AI clients, with practical examples of building useful agent capabilities through the protocol.

Additional Resources 📚
- Blog Post
- Official MCP Documentation
- MCP GitHub Repository

🎓 Educational and Research Agents

ATLAS: Academic Task and Learning Agent System

Overview 🔎
ATLAS demonstrates how to build an intelligent multi-agent system that transforms academic support through AI-powered assistance. The system leverages LangGraph’s workflow framework to coordinate multiple specialized agents that provide personalized academic planning, note-taking, and advisory support.

Implementation 🛠️
Implements a state-managed multi-agent architecture using four specialized agents (Coordinator, Planner, Notewriter, and Advisor) working in concert through LangGraph’s workflow framework. The system features sophisticated workflows for profile analysis and academic support, with continuous adaptation based on student performance and feedback.

Additional Resources 📚
- YouTube Explanation
- Blog Post
Scientific Paper Agent - Literature Review

Overview 🔎
An intelligent research assistant that helps users navigate, understand, and analyze scientific literature through an orchestrated workflow. The system combines academic APIs with sophisticated paper processing techniques to automate literature review tasks, enabling researchers to efficiently extract insights from academic papers while maintaining research rigor and quality control.

Implementation 🛠️
Leverages LangGraph to create a five-node workflow system including decision making, planning, tool execution, and quality validation nodes. The system integrates the CORE API for paper access, PDFplumber for document processing, and advanced language models for analysis. Key features include a retry mechanism for robust paper downloads, structured data handling through Pydantic models, and quality-focused improvement cycles with human-in-the-loop validation options.

Additional Resources 📚
- YouTube Explanation
- Blog Post
Chiron - A Feynman-Enhanced Learning Agent

Overview 🔎
An adaptive learning agent that guides users through educational content using a structured checkpoint system and Feynman-style teaching. The system processes learning materials (either user-provided or web-retrieved), verifies understanding through interactive checkpoints, and provides simplified explanations when needed, creating a personalized learning experience that mimics one-on-one tutoring.

Implementation 🛠️
Uses LangGraph to orchestrate a learning workflow that includes checkpoint definition, context building, understanding verification, and Feynman teaching nodes. The system integrates web search for dynamic content retrieval, employs semantic chunking for context processing, and manages embeddings for relevant information retrieval. Key features include a 70% understanding threshold for progression, interactive human-in-the-loop validation, and structured output through Pydantic models for consistent data handling.

Additional Resources 📚
- YouTube Explanation

💼 Business and Professional Agents

Customer Support Agent (LangGraph)

Overview 🔎
An intelligent customer support agent using LangGraph categorizes queries, analyzes sentiment, and provides appropriate responses or escalates issues.

Implementation 🛠️
Utilizes LangGraph to create a workflow combining state management, query categorization, sentiment analysis, and response generation.
Essay Grading Agent (LangGraph)

Overview 🔎
An automated essay grading system using LangGraph and an LLM model evaluates essays based on relevance, grammar, structure, and depth of analysis.

Implementation 🛠️
Utilizes a state graph to define the grading workflow, incorporating separate grading functions for each criterion.
Travel Planning Agent (LangGraph)

Overview 🔎
A Travel Planner using LangGraph demonstrates how to build a stateful, multi-step conversational AI application that collects user input and generates personalized travel itineraries.

Implementation 🛠️
Utilizes StateGraph to define the application flow, incorporates custom PlannerState for process management.
GenAI Career Assistant Agent

Overview 🔎
The GenAI Career Assistant demonstrates how to create a multi-agent system that provides personalized guidance for careers in Generative AI. Using LangGraph and Gemini LLM, the system delivers customized learning paths, resume assistance, interview preparation, and job search support.

Implementation 🛠️
Leverages a multi-agent architecture using LangGraph to coordinate specialized agents (Learning, Resume, Interview, Job Search) through TypedDict-based state management. The system employs sophisticated query categorization and routing while integrating with external tools like DuckDuckGo for job searches and dynamic content generation.

Additional Resources 📚
- YouTube Explanation
Project Manager Assistant Agent

Overview 🔎
An AI agent designed to assist in project management tasks by automating the process of creating actionable tasks from project descriptions, identifying dependencies, scheduling work, and assigning tasks to team members based on expertise. The system includes risk assessment and self-reflection capabilities to optimize project plans through multiple iterations, aiming to minimize overall project risk.

Implementation 🛠️
Leverages LangGraph to orchestrate a workflow of specialized nodes including task generation, dependency mapping, scheduling, allocation, and risk assessment. Each node uses GPT-4o-mini for structured outputs following Pydantic models. The system implements a feedback loop for self-improvement, where risk scores trigger reflection cycles that generate insights to optimize the project plan. Visualization tools display Gantt charts of the generated schedules across iterations.

Additional Resources 📚
- YouTube Explanation
Contract Analysis Assistant (ClauseAI)

Overview 🔎
ClauseAI demonstrates how to build an AI-powered contract analysis system using a multi-agent approach. The system employs specialized AI agents for different aspects of contract review, from clause analysis to compliance checking, and leverages LangGraph for workflow orchestration and Pinecone for efficient clause retrieval and comparison.

Implementation 🛠️
Implements a sophisticated state-based workflow using LangGraph to coordinate multiple AI agents through contract analysis stages. The system features Pydantic models for data validation, vector storage with Pinecone for clause comparison, and LLM-based analysis for generating comprehensive contract reports. The implementation includes parallel processing capabilities and customizable report generation based on user requirements.

Additional Resources 📚
- YouTube Explanation
E2E Testing Agent

Overview 🔎
The E2E Testing Agent demonstrates how to build an AI-powered system that converts natural language test instructions into executable end-to-end web tests. Using LangGraph for workflow orchestration and Playwright for browser automation, the system enables users to specify test cases in plain English while handling the complexity of test generation and execution.

Implementation 🛠️
Implements a structured workflow using LangGraph to coordinate test generation, validation, and execution. The system features TypedDict state management, integration with Playwright for browser automation, and LLM-based code generation for converting natural language instructions into executable test scripts. The implementation includes DOM state analysis, error handling, and comprehensive test reporting.

Additional Resources 📚
- YouTube Explanation

🎨 Creative and Content Generation Agents

GIF Animation Generator Agent (LangGraph)

Overview 🔎
A GIF animation generator that integrates LangGraph for workflow management, GPT-4 for text generation, and DALL-E for image creation, producing custom animations from user prompts.

Implementation 🛠️
Utilizes LangGraph to orchestrate a workflow that generates character descriptions, plots, and image prompts using GPT-4, creates images with DALL-E 3, and assembles them into GIFs using PIL. Employs asynchronous programming for efficient parallel processing.
TTS Poem Generator Agent (LangGraph)

Overview 🔎
An advanced text-to-speech (TTS) agent using LangGraph and OpenAI’s APIs classifies input text, processes it based on content type, and generates corresponding speech output.

Implementation 🛠️
Utilizes LangGraph to orchestrate a workflow that classifies input text using GPT models, applies content-specific processing, and converts the processed text to speech using OpenAI’s TTS API. The system adapts its output based on the identified content type (general, poem, news, or joke).
Music Compositor Agent (LangGraph)

Overview 🔎
An AI Music Compositor using LangGraph and OpenAI’s language models generates custom musical compositions based on user input. The system processes the input through specialized components, each contributing to the final musical piece, which is then converted to a playable MIDI file.

Implementation 🛠️
LangGraph orchestrates a workflow that transforms user input into a musical composition, using ChatOpenAI (GPT-4) to generate melody, harmony, and rhythm, which are then style-adapted. The final AI-generated composition is converted to a MIDI file using music21 and can be played back using pygame.
Content Intelligence: Multi-Platform Content Generation Agent

Overview 🔎
Content Intelligence demonstrates how to build an advanced content generation system that transforms input text into platform-optimized content across multiple social media channels. The system employs LangGraph for workflow orchestration to analyze content, conduct research, and generate tailored content while maintaining brand consistency across different platforms.

Implementation 🛠️
Implements a sophisticated workflow using LangGraph to coordinate multiple specialized nodes (Summary, Research, Platform-Specific) through the content generation process. The system features TypedDict and Pydantic models for state management, integration with Tavily Search for research enhancement, and platform-specific content generation using GPT-4. The implementation includes parallel processing for multiple platforms and customizable content templates.

Additional Resources 📚
- YouTube Explanation
Business Meme Generator Using LangGraph and Memegen.link

Overview 🔎
The Business Meme Generator demonstrates how to create an AI-powered system that generates contextually relevant memes based on company website analysis. Using LangGraph for workflow orchestration, the system combines Groq’s Llama model for text analysis and the Memegen.link API to automatically produce brand-aligned memes for digital marketing.

Implementation 🛠️
Implements a state-managed workflow using LangGraph to coordinate website content analysis, meme concept generation, and image creation. The system features Pydantic models for data validation, asynchronous processing with aiohttp, and integration with external APIs (Groq, Memegen.link) to create a complete meme generation pipeline with customizable templates.

Additional Resources 📚
- YouTube Explanation
Murder Mystery Game with LLM Agents

Overview 🔎
A text-based detective game that utilizes autonomous LLM agents as interactive characters in a procedurally generated murder mystery. Drawing inspiration from the UNBOUNDED paper, the system creates unique scenarios each time, with players taking on the role of Sherlock Holmes to solve the case through character interviews and deductive reasoning.

Implementation 🛠️
Leverages two LangGraph workflows - a main game loop for story/character generation and game progression, and a conversation sub-graph for character interactions. The system uses a combination of LLM-powered narrative generation, character AI, and structured game mechanics to create an immersive investigative experience with replayable storylines.

Additional Resources 📚
- YouTube Explanation

📊 Analysis and Information Processing Agents

Memory-Enhanced Conversational Agent

Overview 🔎
A memory-enhanced conversational AI agent incorporates short-term and long-term memory systems to maintain context within conversations and across multiple sessions, improving interaction quality and personalization.

Implementation 🛠️
Integrates a language model with separate short-term and long-term memory stores, utilizes a prompt template incorporating both memory types, and employs a memory manager for storage and retrieval. The system includes an interaction loop that updates and utilizes memories for each response.
Multi-Agent Collaboration System

Overview 🔎
A multi-agent collaboration system combining historical research with data analysis, leveraging large language models to simulate specialized agents working together to answer complex historical questions.

Implementation 🛠️
Utilizes a base Agent class to create specialized HistoryResearchAgent and DataAnalysisAgent, orchestrated by a HistoryDataCollaborationSystem. The system follows a five-step process: historical context provision, data needs identification, historical data provision, data analysis, and final synthesis.
Self-Improving Agent

Overview 🔎
A Self-Improving Agent using LangChain engages in conversations, learns from interactions, and continuously improves its performance over time through reflection and adaptation.

Implementation 🛠️
Integrates a language model with chat history management, response generation, and a reflection mechanism. The system employs a learning system that incorporates insights from reflection to enhance future performance, creating a continuous improvement loop.
Task-Oriented Agent

Overview 🔎
A language model application using LangChain that summarizes text and translates the summary to Spanish, combining custom functions, structured tools, and an agent for efficient text processing.

Implementation 🛠️
Utilizes custom functions for summarization and translation, wrapped as structured tools. Employs a prompt template to guide the agent, which orchestrates the use of tools. An agent executor manages the process, taking input text and producing both an English summary and its Spanish translation.
Internet Search and Summarize Agent

Overview 🔎
An intelligent web research assistant that combines web search capabilities with AI-powered summarization, automating the process of gathering information from the internet and distilling it into concise, relevant summaries.

Implementation 🛠️
Integrates a web search module using DuckDuckGo’s API, a result parser, and a text summarization engine leveraging OpenAI’s language models. The system performs site-specific or general searches, extracts relevant content, generates concise summaries, and compiles attributed results for efficient information retrieval and synthesis.
Multi agent research team - Autogen

Overview 🔎
This technique explores a multi-agent system for collaborative research using the AutoGen library. It employs agents to solve tasks collaboratively, focusing on efficient execution and quality assurance. The system enhances research by distributing tasks among specialized agents.

Implementation 🛠️
Agents are configured with specific roles using the GPT-4 model, including admin, developer, planner, executor, and quality assurance. Interaction management ensures orderly communication with defined transitions. Task execution involves collaborative planning, coding, execution, and quality checking, demonstrating a scalable framework for various domains.

Additional Resources 📚
- comprehensive solution with UI
- Blogpost
Sales Call Analyzer

Overview 🔎
An intelligent system that automates the analysis of sales call recordings by combining audio transcription with advanced natural language processing. The analyzer transcribes audio using OpenAI’s Whisper, processes the text using NLP techniques, and generates comprehensive reports including sentiment analysis, key phrases, pain points, and actionable recommendations to improve sales performance.

Implementation 🛠️
Utilizes multiple components in a structured workflow: OpenAI Whisper for audio transcription, CrewAI for task automation and agent management, and LangChain for orchestrating the analysis pipeline. The system processes audio through a series of steps from transcription to detailed analysis, leveraging custom agents and tasks to generate structured JSON reports containing insights about customer sentiment, sales opportunities, and recommended improvements.

Additional Resources 📚
- YouTube Explanation
Weather Emergency & Response System

Overview 🔎
A comprehensive system demonstrating two agent graph implementations for weather emergency response: a real-time graph processing live weather data, and a hybrid graph combining real and simulated data for testing high-severity scenarios. The system handles complete workflow from data gathering through emergency plan generation, with automated notifications and human verification steps.

Implementation 🛠️
Utilizes LangGraph for orchestrating complex workflows with state management, integrating OpenWeatherMap API for real-time data, and Gemini for analysis and response generation. The system incorporates email notifications, social media monitoring simulation, and severity-based routing with configurable human verification for low/medium severity events.

Additional Resources 📚
- YouTube Explanation
Self-Healing Codebase System

Overview 🔎
An intelligent system that automatically detects, diagnoses, and fixes runtime code errors using LangGraph workflow orchestration and ChromaDB vector storage. The system maintains a memory of encountered bugs and their fixes through vector embeddings, enabling pattern recognition for similar errors across the codebase.

Implementation 🛠️
Utilizes a state-based graph workflow that processes function definitions and runtime arguments through specialized nodes for error detection, code analysis, and fix generation. Incorporates ChromaDB for vector-based storage of bug patterns and fixes, with automated search and retrieval capabilities for similar error patterns, while maintaining code execution safety through structured validation steps.

Additional Resources 📚
- YouTube Explanation
DataScribe: AI-Powered Schema Explorer

Overview 🔎
An intelligent agent system that enables intuitive exploration and querying of relational databases through natural language interactions. The system utilizes a fleet of specialized agents, coordinated by a stateful Supervisor, to handle schema discovery, query planning, and data analysis tasks while maintaining contextual understanding through vector-based relationship graphs.

Implementation 🛠️
Leverages LangGraph for orchestrating a multi-agent workflow including discovery, inference, and planning agents, with NetworkX for relationship graph visualization and management. The system incorporates dynamic state management through TypedDict classes, maintains database context between sessions using a db_graph attribute, and includes safety measures to prevent unauthorized database modifications.
Memory-Enhanced Email Agent (LangGraph & LangMem)

Overview 🔎
An intelligent email assistant that combines three types of memory (semantic, episodic, and procedural) to create a system that improves over time. The agent can triage incoming emails, draft contextually appropriate responses using stored knowledge, and enhance its performance based on user feedback.

Implementation 🛠️
Leverages LangGraph for workflow orchestration and LangMem for sophisticated memory management across multiple memory types. The system implements a triage workflow with memory-enhanced decision making, specialized tools for email composition and calendar management, and a self-improvement mechanism that updates its own prompts based on feedback and past performance.

Additional Resources 📚
- **Blog Post

📰 News and Information Agents

News TL;DR using LangGraph

Overview 🔎
A news summarization system that generates concise TL;DR summaries of current events based on user queries. The system leverages large language models for decision making and summarization while integrating with news APIs to access up-to-date content, allowing users to quickly catch up on topics of interest through generated bullet-point summaries.

Implementation 🛠️
Utilizes LangGraph to orchestrate a workflow combining multiple components: GPT-4o-mini for generating search terms and article summaries, NewsAPI for retrieving article metadata, BeautifulSoup for web scraping article content, and Asyncio for concurrent processing. The system follows a structured pipeline from query processing through article selection and summarization, managing the flow between components to produce relevant TL;DRs of current news articles.

Additional Resources 📚
- YouTube Explanation
- Blog Post
AInsight: AI/ML Weekly News Reporter

Overview 🔎
AInsight demonstrates how to build an intelligent news aggregation and summarization system using a multi-agent architecture. The system employs three specialized agents (NewsSearcher, Summarizer, Publisher) to automatically collect, process and summarize AI/ML news for general audiences through LangGraph-based workflow orchestration.

Implementation 🛠️
Implements a state-managed multi-agent system using LangGraph to coordinate the news collection (Tavily API), technical content summarization (GPT-4), and report generation processes. The system features modular architecture with TypedDict-based state management, external API integration, and markdown report generation with customizable templates.

Additional Resources 📚
- YouTube Explanation
Journalism-Focused AI Assistant

Overview 🔎
A specialized AI assistant that helps journalists tackle modern journalistic challenges like misinformation, bias, and information overload. The system integrates fact-checking, tone analysis, summarization, and grammar review tools to enhance the accuracy and efficiency of journalistic work while maintaining ethical reporting standards.

Implementation 🛠️
Leverages LangGraph to orchestrate a workflow of specialized components including language models for analysis and generation, web search integration via DuckDuckGo’s API, document parsing tools like PyMuPDFLoader and WebBaseLoader, text splitting with RecursiveCharacterTextSplitter, and structured JSON outputs. Each component works together through a unified workflow to analyze content, verify facts, detect bias, extract quotes, and generate comprehensive reports.
Blog Writer (Open AI Swarm)

Overview 🔎
A multi-agent system for collaborative blog post creation using OpenAI’s Swarm package. It leverages specialized agents to perform research, planning, writing, and editing tasks efficiently.

Implementation 🛠️
Utilizes OpenAI’s Swarm Package to manage agent interactions. Includes an admin, researcher, planner, writer, and editor, each with specific roles. The system follows a structured workflow: topic setting, outlining, research, drafting, and editing. This approach enhances content creation through task distribution, specialization, and collaborative problem-solving.

Additional Resources 📚
- Swarm Repo
Podcast Internet Search and Generate Agent 🎙️

Overview 🔎
A two step agent that first searches the internet for a given topic and then generates a podcast on the topic found. The search step uses a search agent and search function to find the most relevant information. The second step uses a podcast generation agent and generation function to create a podcast on the topic found.

Implementation 🛠️
Utilizes LangGraph to orchestrate a two-step workflow. The first step involves a search agent and function to gather information from the internet. The second step uses a podcast generation agent and function to create a podcast based on the gathered information.

🛍️ Shopping and Product Analysis Agents

ShopGenie - Redefining Online Shopping Customer Experience

Overview 🔎
An AI-powered shopping assistant that helps customers make informed purchasing decisions even without domain expertise. The system analyzes product information from multiple sources, compares specifications and reviews, identifies the best option based on user needs, and delivers recommendations through email with supporting video reviews, creating a comprehensive shopping experience.

Implementation 🛠️
Uses LangGraph to orchestrate a workflow combining Tavily for web search, Llama-3.1-70B for structured data analysis and product comparison, and YouTube API for review video retrieval. The system processes search results through multiple nodes including schema mapping, product comparison, review identification, and email generation. Key features include structured Pydantic models for consistent data handling, retry mechanisms for robust API interactions, and email delivery through SMTP for sharing recommendations.

Additional Resources 📚
- YouTube Explanation
Car Buyer AI Agent

Overview 🔎
The Smart Product Buyer AI Agent demonstrates how to build an intelligent system that assists users in making informed purchasing decisions. Using LangGraph and LLM-based intelligence, the system processes user requirements, scrapes product listings from websites like AutoTrader, and provides detailed analysis and recommendations for car purchases.

Implementation 🛠️
Implements a state-based workflow using LangGraph to coordinate user interaction, web scraping, and decision support. The system features TypedDict state management, async web scraping with Playwright, and integrates with external APIs for comprehensive product analysis. The implementation includes a Gradio interface for real-time chat interaction and modular scraper architecture for easy extension to additional product categories.

Additional Resources 📚
- YouTube Explanation

🎯 Task Management and Productivity Agents

Taskifier - Intelligent Task Allocation & Management

Overview 🔎
An intelligent task management system that analyzes user work styles and creates personalized task breakdown strategies, born from the observation that procrastination often stems from task ambiguity among students and early-career professionals. The system evaluates historical work patterns, gathers relevant task information through web search, and generates customized step-by-step approaches to optimize productivity and reduce workflow paralysis.

Implementation 🛠️
Leverages LangGraph for orchestrating a multi-step workflow including work style analysis, information gathering via Tavily API, and customized plan generation. The system maintains state through the process, integrating historical work pattern data with fresh task research to output detailed, personalized task execution plans aligned with the user’s natural working style.

Additional Resources 📚
- YouTube Explanation
Grocery Management Agents System

Overview 🔎
A multi-agent system built with CrewAI that automates grocery management tasks including receipt interpretation, expiration date tracking, inventory management, and recipe recommendations. The system uses specialized agents to extract data from receipts, estimate product shelf life, track consumption, and suggest recipes to minimize food waste.

Implementation 🛠️
Implements four specialized agents using CrewAI - a Receipt Interpreter that extracts item details from receipts, an Expiration Date Estimator that determines shelf life using online sources, a Grocery Tracker that maintains inventory based on consumption, and a Recipe Recommender that suggests meals using available ingredients. Each agent has specific tools and tasks orchestrated through a crew workflow.

Additional Resources 📚
- YouTube Explanation

🔍 Quality Assurance and Testing Agents

LangGraph-Based Systems Inspector

Overview 🔎
A comprehensive testing and validation tool for LangGraph-based applications that automatically analyzes system architecture, generates test cases, and identifies potential vulnerabilities through multi-agent inspection. The inspector employs specialized AI testers to evaluate different aspects of the system, from basic functionality to security concerns and edge cases.

Implementation 🛠️
Integrates LangGraph for workflow orchestration, multiple LLM-powered testing agents, and a structured evaluation pipeline that includes static analysis, test case generation, and results verification. The system uses Pydantic for data validation, NetworkX for graph representation, and implements a modular architecture that allows for parallel test execution and comprehensive result analysis.

Additional Resources 📚
- YouTube Explanation
- Blog Post
EU Green Deal FAQ Bot

Overview 🔎
The EU Green Deal FAQ Bot demonstrates how to build a RAG-based AI agent that helps businesses understand EU green deal policies. The system processes complex regulatory documents into manageable chunks and provides instant, accurate answers to common questions about environmental compliance, emissions reporting, and waste management requirements.

Implementation 🛠️
Implements a sophisticated RAG pipeline using FAISS vectorstore for document storage, semantic chunking for preprocessing, and multiple specialized agents (Retriever, Summarizer, Evaluator) for query processing. The system features query rephrasing for improved accuracy, cross-reference with gold Q&A datasets for answer validation, and comprehensive evaluation metrics to ensure response quality and relevance.

Additional Resources 📚
- YouTube Explanation
Systematic Review Automation System + Paper Draft Creation

Overview 🔎
A comprehensive system for automating academic systematic reviews using a directed graph architecture and LangChain components. The system generates complete, publication-ready systematic review papers, automatically processing everything from literature search through final draft generation with multiple revision cycles.

Implementation 🛠️
Utilizes a state-based graph workflow that handles paper search and selection (up to 3 papers), PDF processing, and generates a complete academic paper with all standard sections (abstract, introduction, methods, results, conclusions, references). The system incorporates multiple revision cycles with automated critique and improvement phases, all orchestrated through LangGraph state management.

Additional Resources 📚
- YouTube Explanation

🌟 Special Advanced Technique 🌟

Sophisticated Controllable Agent for Complex RAG Tasks 🤖

Overview 🔎
An advanced RAG solution designed to tackle complex questions that simple semantic similarity-based retrieval cannot solve. This approach uses a sophisticated deterministic graph as the “brain” 🧠 of a highly controllable autonomous agent, capable of answering non-trivial questions from your own data.

Implementation 🛠️
• Implement a multi-step process involving question anonymization, high-level planning, task breakdown, adaptive information retrieval and question answering, continuous re-planning, and rigorous answer verification to ensure grounded and accurate responses.

Getting Started

To begin exploring and building GenAI agents:

Clone this repository:

`1`	`git clone https://github.com/NirDiamant/GenAI_Agents.git`

Navigate to the technique you’re interested in:
1

cd all_agents_tutorials/technique-name
Follow the detailed implementation guide in each technique’s notebook.

Contributing

We welcome contributions from the community! If you have a new technique or improvement to suggest:

Fork the repository
Create your feature branch: git checkout -b feature/AmazingFeature
Commit your changes: git commit -m 'Add some AmazingFeature'
Push to the branch: git push origin feature/AmazingFeature
Open a pull request

Contributors

License

This project is licensed under a custom non-commercial license - see the LICENSE file for details.

⭐️ If you find this repository helpful, please consider giving it a star!

Keywords: GenAI, Generative AI, Agents, NLP, AI, Machine Learning, Natural Language Processing, LLM, Conversational AI, Task-Oriented AI

PraisonAI

Tue, 03 Jun 2025 15:32:36 +0800

MervinPraison/PraisonAI

Praison AI

PraisonAI is a production-ready Multi-AI Agents framework with self-reflection, designed to create AI Agents to automate and solve problems ranging from simple tasks to complex challenges. By integrating PraisonAI Agents, AG2 (Formerly AutoGen), and CrewAI into a low-code solution, it streamlines the building and management of multi-agent LLM systems, emphasising simplicity, customisation, and effective human-agent collaboration.

Key Features

🤖 Automated AI Agents Creation
🔄 Self Reflection AI Agents
🧠 Reasoning AI Agents
👁️ Multi Modal AI Agents
🤝 Multi Agent Collaboration
🎭 AI Agent Workflow
📚 Add Custom Knowledge
🧠 Agents with Short and Long Term Memory
📄 Chat with PDF Agents
💻 Code Interpreter Agents
📚 RAG Agents
🤔 Async & Parallel Processing
🔄 Auto Agents
🔢 Math Agents
🎯 Structured Output Agents
🔗 LangChain Integrated Agents
📞 Callback Agents
🤏 Mini AI Agents
🛠️ 100+ Custom Tools
📄 YAML Configuration
💯 100+ LLM Support

Using Python Code

Light weight package dedicated for coding:

`1`	`pip install praisonaiagents`

`1`	`export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx`

1. Single Agent

Create app.py file and add the code below:

1
2
3

from praisonaiagents import Agent
agent = Agent(instructions="Your are a helpful AI assistant")
agent.start("Write a movie script about a robot in Mars")

Run:

`1`	`python app.py`

2. Multi Agents

Create app.py file and add the code below:

from praisonaiagents import Agent, PraisonAIAgents

research_agent = Agent(instructions="Research about AI")
summarise_agent = Agent(instructions="Summarise research agent's findings")
agents = PraisonAIAgents(agents=[research_agent, summarise_agent])
agents.start()

Run:

`1`	`python app.py`

Using No Code

Auto Mode:

1
2
3

pip install praisonai
export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
praisonai --auto create a movie script about Robots in Mars

Using JavaScript Code

1
2

npm install praisonai
export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx

1
2
3

const { Agent } = require('praisonai');
const agent = new Agent({ instructions: 'You are a helpful AI assistant' });
agent.start('Write a movie script about a robot in Mars');

AI Agents Flow

  graph LR
    %% Define the main flow
    Start([▶ Start]) --> Agent1
    Agent1 --> Process[⚙ Process]
    Process --> Agent2
    Agent2 --> Output([✓ Output])
    Process -.-> Agent1
    
    %% Define subgraphs for agents and their tasks
    subgraph Agent1[ ]
        Task1[📋 Task]
        AgentIcon1[🤖 AI Agent]
        Tools1[🔧 Tools]
        
        Task1 --- AgentIcon1
        AgentIcon1 --- Tools1
    end
    
    subgraph Agent2[ ]
        Task2[📋 Task]
        AgentIcon2[🤖 AI Agent]
        Tools2[🔧 Tools]
        
        Task2 --- AgentIcon2
        AgentIcon2 --- Tools2
    end

    classDef input fill:#8B0000,stroke:#7C90A0,color:#fff
    classDef process fill:#189AB4,stroke:#7C90A0,color:#fff
    classDef tools fill:#2E8B57,stroke:#7C90A0,color:#fff
    classDef transparent fill:none,stroke:none

    class Start,Output,Task1,Task2 input
    class Process,AgentIcon1,AgentIcon2 process
    class Tools1,Tools2 tools
    class Agent1,Agent2 transparent

AI Agents with Tools

Create AI agents that can use tools to interact with external systems and perform actions.

  flowchart TB
    subgraph Tools
        direction TB
        T3[Internet Search]
        T1[Code Execution]
        T2[Formatting]
    end

    Input[Input] ---> Agents
    subgraph Agents
        direction LR
        A1[Agent 1]
        A2[Agent 2]
        A3[Agent 3]
    end
    Agents ---> Output[Output]

    T3 --> A1
    T1 --> A2
    T2 --> A3

    style Tools fill:#189AB4,color:#fff
    style Agents fill:#8B0000,color:#fff
    style Input fill:#8B0000,color:#fff
    style Output fill:#8B0000,color:#fff

AI Agents with Memory

Create AI agents with memory capabilities for maintaining context and information across tasks.

  flowchart TB
    subgraph Memory
        direction TB
        STM[Short Term]
        LTM[Long Term]
    end

    subgraph Store
        direction TB
        DB[(Vector DB)]
    end

    Input[Input] ---> Agents
    subgraph Agents
        direction LR
        A1[Agent 1]
        A2[Agent 2]
        A3[Agent 3]
    end
    Agents ---> Output[Output]

    Memory <--> Store
    Store <--> A1
    Store <--> A2
    Store <--> A3

    style Memory fill:#189AB4,color:#fff
    style Store fill:#2E8B57,color:#fff
    style Agents fill:#8B0000,color:#fff
    style Input fill:#8B0000,color:#fff
    style Output fill:#8B0000,color:#fff

AI Agents with Different Processes

Sequential Process

The simplest form of task execution where tasks are performed one after another.

  graph LR
    Input[Input] --> A1
    subgraph Agents
        direction LR
        A1[Agent 1] --> A2[Agent 2] --> A3[Agent 3]
    end
    A3 --> Output[Output]

    classDef input fill:#8B0000,stroke:#7C90A0,color:#fff
    classDef process fill:#189AB4,stroke:#7C90A0,color:#fff
    classDef transparent fill:none,stroke:none

    class Input,Output input
    class A1,A2,A3 process
    class Agents transparent

Hierarchical Process

Uses a manager agent to coordinate task execution and agent assignments.

  graph TB
    Input[Input] --> Manager
    
    subgraph Agents
        Manager[Manager Agent]
        
        subgraph Workers
            direction LR
            W1[Worker 1]
            W2[Worker 2]
            W3[Worker 3]
        end
        
        Manager --> W1
        Manager --> W2
        Manager --> W3
    end
    
    W1 --> Manager
    W2 --> Manager
    W3 --> Manager
    Manager --> Output[Output]

    classDef input fill:#8B0000,stroke:#7C90A0,color:#fff
    classDef process fill:#189AB4,stroke:#7C90A0,color:#fff
    classDef transparent fill:none,stroke:none

    class Input,Output input
    class Manager,W1,W2,W3 process
    class Agents,Workers transparent

Workflow Process

Advanced process type supporting complex task relationships and conditional execution.

  graph LR
    Input[Input] --> Start
    
    subgraph Workflow
        direction LR
        Start[Start] --> C1{Condition}
        C1 --> |Yes| A1[Agent 1]
        C1 --> |No| A2[Agent 2]
        A1 --> Join
        A2 --> Join
        Join --> A3[Agent 3]
    end
    
    A3 --> Output[Output]

    classDef input fill:#8B0000,stroke:#7C90A0,color:#fff
    classDef process fill:#189AB4,stroke:#7C90A0,color:#fff
    classDef decision fill:#2E8B57,stroke:#7C90A0,color:#fff
    classDef transparent fill:none,stroke:none

    class Input,Output input
    class Start,A1,A2,A3,Join process
    class C1 decision
    class Workflow transparent

Agentic Routing Workflow

Create AI agents that can dynamically route tasks to specialized LLM instances.

  flowchart LR
    In[In] --> Router[LLM Call Router]
    Router --> LLM1[LLM Call 1]
    Router --> LLM2[LLM Call 2]
    Router --> LLM3[LLM Call 3]
    LLM1 --> Out[Out]
    LLM2 --> Out
    LLM3 --> Out
    
    style In fill:#8B0000,color:#fff
    style Router fill:#2E8B57,color:#fff
    style LLM1 fill:#2E8B57,color:#fff
    style LLM2 fill:#2E8B57,color:#fff
    style LLM3 fill:#2E8B57,color:#fff
    style Out fill:#8B0000,color:#fff

Agentic Orchestrator Worker

Create AI agents that orchestrate and distribute tasks among specialized workers.

  flowchart LR
    In[In] --> Router[LLM Call Router]
    Router --> LLM1[LLM Call 1]
    Router --> LLM2[LLM Call 2]
    Router --> LLM3[LLM Call 3]
    LLM1 --> Synthesizer[Synthesizer]
    LLM2 --> Synthesizer
    LLM3 --> Synthesizer
    Synthesizer --> Out[Out]
    
    style In fill:#8B0000,color:#fff
    style Router fill:#2E8B57,color:#fff
    style LLM1 fill:#2E8B57,color:#fff
    style LLM2 fill:#2E8B57,color:#fff
    style LLM3 fill:#2E8B57,color:#fff
    style Synthesizer fill:#2E8B57,color:#fff
    style Out fill:#8B0000,color:#fff

Agentic Autonomous Workflow

Create AI agents that can autonomously monitor, act, and adapt based on environment feedback.

  flowchart LR
    Human[Human] <--> LLM[LLM Call]
    LLM -->|ACTION| Environment[Environment]
    Environment -->|FEEDBACK| LLM
    LLM --> Stop[Stop]
    
    style Human fill:#8B0000,color:#fff
    style LLM fill:#2E8B57,color:#fff
    style Environment fill:#8B0000,color:#fff
    style Stop fill:#333,color:#fff

Agentic Parallelization

Create AI agents that can execute tasks in parallel for improved performance.

  flowchart LR
    In[In] --> LLM2[LLM Call 2]
    In --> LLM1[LLM Call 1]
    In --> LLM3[LLM Call 3]
    LLM1 --> Aggregator[Aggregator]
    LLM2 --> Aggregator
    LLM3 --> Aggregator
    Aggregator --> Out[Out]
    
    style In fill:#8B0000,color:#fff
    style LLM1 fill:#2E8B57,color:#fff
    style LLM2 fill:#2E8B57,color:#fff
    style LLM3 fill:#2E8B57,color:#fff
    style Aggregator fill:#fff,color:#000
    style Out fill:#8B0000,color:#fff

Agentic Prompt Chaining

Create AI agents with sequential prompt chaining for complex workflows.

  flowchart LR
    In[In] --> LLM1[LLM Call 1] --> Gate{Gate}
    Gate -->|Pass| LLM2[LLM Call 2] -->|Output 2| LLM3[LLM Call 3] --> Out[Out]
    Gate -->|Fail| Exit[Exit]
    
    style In fill:#8B0000,color:#fff
    style LLM1 fill:#2E8B57,color:#fff
    style LLM2 fill:#2E8B57,color:#fff
    style LLM3 fill:#2E8B57,color:#fff
    style Out fill:#8B0000,color:#fff
    style Exit fill:#8B0000,color:#fff

Agentic Evaluator Optimizer

Create AI agents that can generate and optimize solutions through iterative feedback.

  flowchart LR
    In[In] --> Generator[LLM Call Generator] 
    Generator -->|SOLUTION| Evaluator[LLM Call Evaluator] -->|ACCEPTED| Out[Out]
    Evaluator -->|REJECTED + FEEDBACK| Generator
    
    style In fill:#8B0000,color:#fff
    style Generator fill:#2E8B57,color:#fff
    style Evaluator fill:#2E8B57,color:#fff
    style Out fill:#8B0000,color:#fff

Repetitive Agents

Create AI agents that can efficiently handle repetitive tasks through automated loops.

  flowchart LR
    In[Input] --> LoopAgent[("Looping Agent")]
    LoopAgent --> Task[Task]
    Task --> |Next iteration| LoopAgent
    Task --> |Done| Out[Output]
    
    style In fill:#8B0000,color:#fff
    style LoopAgent fill:#2E8B57,color:#fff,shape:circle
    style Task fill:#2E8B57,color:#fff
    style Out fill:#8B0000,color:#fff

Adding Models

Ollama Integration

`1`	`export OPENAI_BASE_URL=http://localhost:11434/v1`

Groq Integration

Replace xxxx with Groq API KEY:

1
2

export OPENAI_API_KEY=xxxxxxxxxxx
export OPENAI_BASE_URL=https://api.groq.com/openai/v1

No Code Options

Agents Playbook

Simple Playbook Example

Create agents.yaml file and add the code below:

framework: praisonai
topic: Artificial Intelligence
roles:
  screenwriter:
    backstory: "Skilled in crafting scripts with engaging dialogue about {topic}."
    goal: Create scripts from concepts.
    role: Screenwriter
    tasks:
      scriptwriting_task:
        description: "Develop scripts with compelling characters and dialogue about {topic}."
        expected_output: "Complete script ready for production."

To run the playbook:

`1`	`praisonai agents.yaml`

Use 100+ Models

https://docs.praison.ai/models/

Development:

Below is used for development only.

Using uv

# Install uv if you haven't already
pip install uv

# Install from requirements
uv pip install -r pyproject.toml

# Install with extras
uv pip install -r pyproject.toml --extra code
uv pip install -r pyproject.toml --extra "crewai,autogen"

Contributing

Fork on GitHub: Use the “Fork” button on the repository page.
Clone your fork: git clone https://github.com/yourusername/praisonAI.git
Create a branch: git checkout -b new-feature
Make changes and commit: git commit -am "Add some feature"
Push to your fork: git push origin new-feature
Submit a pull request via GitHub’s web interface.
Await feedback from project maintainers.

Other Features

🔄 Use CrewAI or AG2 (Formerly AutoGen) Framework
💻 Chat with ENTIRE Codebase
🎨 Interactive UIs
📄 YAML-based Configuration
🛠️ Custom Tool Integration
🔍 Internet Search Capability (using Crawl4AI and Tavily)
🖼️ Vision Language Model (VLM) Support
🎙️ Real-time Voice Interaction

Star History

Video Tutorials

Topic	Video
AI Agents with Self Reflection
Reasoning Data Generating Agent
AI Agents with Reasoning
Multimodal AI Agents
AI Agents Workflow
Async AI Agents
Mini AI Agents
AI Agents with Memory
Repetitive Agents
Introduction
Tools Overview
Custom Tools
Firecrawl Integration
User Interface
Crawl4AI Integration
Chat Interface
Code Interface
Mem0 Integration
Training
Realtime Voice Interface
Call Interface
Reasoning Extract Agents

opik

Wed, 14 May 2025 15:29:35 +0800

comet-ml/opik

English | 简体中文 | 日本語 | 한국어

Opik
Open source LLM evaluation framework

From RAG chatbots to code assistants to complex agentic pipelines and beyond, build LLM systems that run better, faster, and cheaper with tracing, evaluations, and dashboards.

Website • Slack community • Twitter • Documentation

Important change on version 1.7.0

Please check the change log here.

🚀 What is Opik?

Opik is an open-source platform for evaluating, testing and monitoring LLM applications. Built by Comet.

You can use Opik for:

Development:
- Tracing: Track all LLM calls and traces during development and production (Quickstart, Integrations)
- Annotations: Annotate your LLM calls by logging feedback scores using the Python SDK or the UI.
- Playground: Try out different prompts and models in the prompt playground.
Evaluation: Automate the evaluation process of your LLM application:
- Datasets and Experiments: Store test cases and run experiments (Datasets, Evaluate your LLM Application)
- LLM as a judge metrics: Use Opik’s LLM as a judge metric for complex issues like hallucination detection, moderation and RAG evaluation (Answer Relevance, Context Precision
- CI/CD integration: Run evaluations as part of your CI/CD pipeline using our PyTest integration
Production Monitoring:
- Log all your production traces: Opik has been designed to support high volumes of traces, making it easy to monitor your production applications. Even small deployments can ingest more than 40 million traces per day!
- Monitoring dashboards: Review your feedback scores, trace count and tokens over time in the Opik Dashboard.
- Online evaluation metrics: Easily score all your production traces using LLM as a Judge metrics and identify any issues with your production LLM application thanks to Opik’s online evaluation metrics

[!TIP]
If you are looking for features that Opik doesn’t have today, please raise a new Feature request 🚀

🛠️ Installation

Opik is available as a fully open source local installation or using Comet.com as a hosted solution. The easiest way to get started with Opik is by creating a free Comet account at comet.com.

If you’d like to self-host Opik, you can do so by cloning the repository and starting the platform using Docker Compose:

On Linux or Mac do:

# Clone the Opik repository
git clone https://github.com/comet-ml/opik.git

# Navigate to the repository
cd opik

# Start the Opik platform
./opik.sh

On Windows do:

# Clone the Opik repository
git clone https://github.com/comet-ml/opik.git

# Navigate to the repository
cd opik

# Start the Opik platform
powershell -ExecutionPolicy ByPass -c ".\opik.ps1"

Use the --help or --info options to troubleshoot issues.

Once all is up and running, you can now visit localhost:5173 on your browser!

For more information about the different deployment options, please see our deployment guides:

Installation methods	Docs link
Local instance
Kubernetes

🏁 Get Started

To get started, you will need to first install the Python SDK:

`1`	`pip install opik`

Once the SDK is installed, you can configure it by running the opik configure command:

`1`	`opik configure`

This will allow you to configure Opik locally by setting the correct local server address or if you’re using the Cloud platform by setting the API Key

[!TIP]
You can also call the opik.configure(use_local=True) method from your Python code to configure the SDK to run on the local installation.

You are now ready to start logging traces using the Python SDK.

📝 Logging Traces

The easiest way to get started is to use one of our integrations. Opik supports:

Integration	Description	Documentation
OpenAI	Log traces for all OpenAI LLM calls	Documentation
LiteLLM	Call any LLM model using the OpenAI format	Documentation
LangChain	Log traces for all LangChain LLM calls	Documentation
Haystack	Log traces for all Haystack calls	Documentation
Anthropic	Log traces for all Anthropic LLM calls	Documentation
Bedrock	Log traces for all Bedrock LLM calls	Documentation
CrewAI	Log traces for all CrewAI calls	Documentation
DeepSeek	Log traces for all DeepSeek LLM calls	Documentation
DSPy	Log traces for all DSPy runs	Documentation
Gemini	Log traces for all Gemini LLM calls	Documentation
Groq	Log traces for all Groq LLM calls	Documentation
Guardrails	Log traces for all Guardrails validations	Documentation
Instructor	Log traces for all LLM calls made with Instructor	Documentation
LangGraph	Log traces for all LangGraph executions	Documentation
LlamaIndex	Log traces for all LlamaIndex LLM calls	Documentation
Ollama	Log traces for all Ollama LLM calls	Documentation
Predibase	Fine-tune and serve open-source Large Language Models	Documentation
Pydantic AI	Fine-tune and serve open-source Large Language Models	Documentation
Ragas	PydanticAI is a Python agent framework designed to build production apps	Documentation
watsonx	Log traces for all watsonx LLM calls	Documentation

[!TIP]
If the framework you are using is not listed above, feel free to open an issue or submit a PR with the integration.

If you are not using any of the frameworks above, you can also use the track function decorator to log traces:

import opik

opik.configure(use_local=True) # Run locally

@opik.track
def my_llm_function(user_question: str) -> str:
    # Your LLM code here

    return "Hello"

[!TIP]
The track decorator can be used in conjunction with any of our integrations and can also be used to track nested function calls.

🧑‍⚖️ LLM as a Judge metrics

The Python Opik SDK includes a number of LLM as a judge metrics to help you evaluate your LLM application. Learn more about it in the metrics documentation.

To use them, simply import the relevant metric and use the score function:

from opik.evaluation.metrics import Hallucination

metric = Hallucination()
score = metric.score(
    input="What is the capital of France?",
    output="Paris",
    context=["France is a country in Europe."]
)
print(score)

Opik also includes a number of pre-built heuristic metrics as well as the ability to create your own. Learn more about it in the metrics documentation.

🔍 Evaluating your LLM Application

Opik allows you to evaluate your LLM application during development through Datasets and Experiments.

You can also run evaluations as part of your CI/CD pipeline using our PyTest integration.

⭐ Star Us on GitHub

If you find Opik useful, please consider giving us a star! Your support helps us grow our community and continue improving the product.

🤝 Contributing

There are many ways to contribute to Opik:

Submit bug reports and feature requests
Review the documentation and submit Pull Requests to improve it
Speaking or writing about Opik and letting us know
Upvoting popular feature requests to show your support

To learn more about how to contribute to Opik, please see our contributing guidelines.

llm-cookbook

Fri, 11 Apr 2025 15:27:55 +0800

datawhalechina/llm-cookbook

面向开发者的大模型手册 - LLM Cookbook

项目简介

本项目是一个面向开发者的大模型手册，针对国内开发者的实际需求，主打 LLM 全方位入门实践。本项目基于吴恩达老师大模型系列课程内容，对原课程内容进行筛选、翻译、复现和调优，覆盖从 Prompt Engineering 到 RAG 开发、模型微调的全部流程，用最适合国内学习者的方式，指导国内开发者如何学习、入门 LLM 相关项目。

针对不同内容的特点，我们对共计 11 门吴恩达老师的大模型课程进行了翻译复现，并结合国内学习者的实际情况，对不同课程进行了分级和排序，初学者可以先系统学习我们的必修类课程，掌握入门 LLM 所有方向都需要掌握的基础技能和概念，再选择性地学习我们的选修类课程，在自己感兴趣的方向上不断探索和学习。

如果有你非常喜欢但我们还没有进行复现的吴恩达老师大模型课程，我们欢迎每一位开发者参考我们已有课程的格式和写法来对课程进行复现并提交 PR，在 PR 审核通过后，我们会根据课程内容将课程进行分级合并。欢迎每一位开发者的贡献！

在线阅读地址：面向开发者的 LLM 入门课程-在线阅读

PDF下载地址：面向开发者的 LLM 入门教程-PDF

英文原版地址：吴恩达关于大模型的系列课程

项目意义

LLM 正在逐步改变人们的生活，而对于开发者，如何基于 LLM 提供的 API 快速、便捷地开发一些具备更强能力、集成LLM 的应用，来便捷地实现一些更新颖、更实用的能力，是一个急需学习的重要能力。

由吴恩达老师与 OpenAI 合作推出的大模型系列教程，从大模型时代开发者的基础技能出发，深入浅出地介绍了如何基于大模型 API、LangChain 架构快速开发结合大模型强大能力的应用。其中，《Prompt Engineering for Developers》教程面向入门 LLM 的开发者，深入浅出地介绍了对于开发者，如何构造 Prompt 并基于 OpenAI 提供的 API 实现包括总结、推断、转换等多种常用功能，是入门 LLM 开发的经典教程；《Building Systems with the ChatGPT API》教程面向想要基于 LLM 开发应用程序的开发者，简洁有效而又系统全面地介绍了如何基于 ChatGPT API 打造完整的对话系统；《LangChain for LLM Application Development》教程结合经典大模型开源框架 LangChain，介绍了如何基于 LangChain 框架开发具备实用功能、能力全面的应用程序，《LangChain Chat With Your Data》教程则在此基础上进一步介绍了如何使用 LangChain 架构结合个人私有数据开发个性化大模型应用；《Building Generative AI Applications with Gradio》、《Evaluating and Debugging Generative AI》教程分别介绍了两个实用工具 Gradio 与 W&B，指导开发者如何结合这两个工具来打造、评估生成式 AI 应用。

上述教程非常适用于开发者学习以开启基于 LLM 实际搭建应用程序之路。因此，我们将该系列课程翻译为中文，并复现其范例代码，也为其中一个视频增加了中文字幕，支持国内中文学习者直接使用，以帮助中文学习者更好地学习 LLM 开发；我们也同时实现了效果大致相当的中文 Prompt，支持学习者感受中文语境下 LLM 的学习使用，对比掌握多语言语境下的 Prompt 设计与 LLM 开发。未来，我们也将加入更多 Prompt 高级技巧，以丰富本课程内容，帮助开发者掌握更多、更巧妙的 Prompt 技能。

项目受众

所有具备基础 Python 能力，想要入门 LLM 的开发者。

项目亮点

《ChatGPT Prompt Engineering for Developers》、《Building Systems with the ChatGPT API》等教程作为由吴恩达老师与 OpenAI 联合推出的官方教程，在可预见的未来会成为 LLM 的重要入门教程，但是目前还只支持英文版且国内访问受限，打造中文版且国内流畅访问的教程具有重要意义；同时，GPT 对中文、英文具有不同的理解能力，本教程在多次对比、实验之后确定了效果大致相当的中文 Prompt，支持学习者研究如何提升 ChatGPT 在中文语境下的理解与生成能力。

学习指南

本教程适用于所有具备基础 Python 能力，想要入门 LLM 的开发者。

如果你想要开始学习本教程，你需要提前具备：

至少一个 LLM API（最好是 OpenAI，如果是其他 API，你可能需要参考其他教程对 API 调用代码进行修改）
能够使用 Python Jupyter Notebook

本教程共包括 11 门课程，分为必修类、选修类两个类别。必修类课程是我们认为最适合初学者学习以入门 LLM 的课程，包括了入门 LLM 所有方向都需要掌握的基础技能和概念，我们也针对必修类课程制作了适合阅读的在线阅读和 PDF 版本，在学习必修类课程时，我们建议学习者按照我们列出的顺序进行学习；选修类课程是在必修类课程上的拓展延伸，包括了 RAG 开发、模型微调、模型评估等多个方面，适合学习者在掌握了必修类课程之后选择自己感兴趣的方向和课程进行学习。

必修类课程包括：

面向开发者的 Prompt Engineering。基于吴恩达老师《ChatGPT Prompt Engineering for Developers》课程打造，面向入门 LLM 的开发者，深入浅出地介绍了对于开发者，如何构造 Prompt 并基于 OpenAI 提供的 API 实现包括总结、推断、转换等多种常用功能，是入门 LLM 开发的第一步。
搭建基于 ChatGPT 的问答系统。基于吴恩达老师《Building Systems with the ChatGPT API》课程打造，指导开发者如何基于 ChatGPT 提供的 API 开发一个完整的、全面的智能问答系统。通过代码实践，实现了基于 ChatGPT 开发问答系统的全流程，介绍了基于大模型开发的新范式，是大模型开发的实践基础。
使用 LangChain 开发应用程序。基于吴恩达老师《LangChain for LLM Application Development》课程打造，对 LangChain 展开深入介绍，帮助学习者了解如何使用 LangChain，并基于 LangChain 开发完整的、具备强大能力的应用程序。
使用 LangChain 访问个人数据。基于吴恩达老师《LangChain Chat with Your Data》课程打造，深入拓展 LangChain 提供的个人数据访问能力，指导开发者如何使用 LangChain 开发能够访问用户个人数据、提供个性化服务的大模型应用。

选修类课程包括：

使用 Gradio 搭建生成式 AI 应用。基于吴恩达老师《Building Generative AI Applications with Gradio》课程打造，指导开发者如何使用 Gradio 通过 Python 接口程序快速、高效地为生成式 AI 构建用户界面。
评估改进生成式 AI。基于吴恩达老师《Evaluating and Debugging Generative AI》课程打造，结合 wandb，提供一套系统化的方法和工具，帮助开发者有效地跟踪和调试生成式 AI 模型。
微调大语言模型。基于吴恩达老师《Finetuning Large Language Model》课程打造，结合 lamini 框架，讲述如何便捷高效地在本地基于个人数据微调开源大语言模型。
大模型与语义检索。基于吴恩达老师《Large Language Models with Semantic Search》课程打造，针对检索增强生成，讲述了多种高级检索技巧以实现更准确、高效的检索增强 LLM 生成效果。
基于 Chroma 的高级检索。基于吴恩达老师《Advanced Retrieval for AI with Chroma》课程打造，旨在介绍基于 Chroma 的高级检索技术，提升检索结果的准确性。
搭建和评估高级 RAG 应用。基于吴恩达老师《Building and Evaluating Advanced RAG Applications》课程打造，介绍构建和实现高质量RAG系统所需的关键技术和评估框架。
LangChain 的 Functions、Tools 和 Agents。基于吴恩达老师《Functions, Tools and Agents with LangChain》课程打造，介绍如何基于 LangChain 的新语法构建 Agent。
Prompt 高级技巧。包括 CoT、自我一致性等多种 Prompt 高级技巧的基础理论与代码实现。

其他资料包括：

双语字幕视频地址：吴恩达 x OpenAI的Prompt Engineering课程专业翻译版

中英双语字幕下载：《ChatGPT提示工程》非官方版中英双语字幕

视频讲解：面向开发者的 Prompt Engineering 讲解（数字游民大会）

目录结构说明：

content：基于原课程复现的双语版代码，可运行的 Notebook，更新频率最高，更新速度最快。

docs：必修类课程文字教程版在线阅读源码，适合阅读的 md。

figures：图片文件。

致谢

核心贡献者

邹雨衡-项目负责人（Datawhale成员-对外经济贸易大学研究生）
左春生-项目负责人（内容创作者-Datawhale成员）
长琴-项目发起人（内容创作者-Datawhale成员-AI算法工程师）
玉琳-项目发起人（内容创作者-Datawhale成员）
徐虎-教程编撰者（内容创作者-Datawhale成员）
刘伟鸿-教程编撰者（内容创作者-江南大学非全研究生）
Joye-教程编撰者（内容创作者-数据科学家）
高立业（内容创作者-DataWhale成员-算法工程师）
邓宇文（内容创作者-Datawhale成员）
魂兮（内容创作者-前端工程师）
宋志学（内容创作者-Datawhale成员）
韩颐堃（内容创作者-Datawhale成员）
陈逸涵 (内容创作者-Datawhale意向成员-AI爱好者)
仲泰（内容创作者-Datawhale成员）
万礼行（内容创作者-视频翻译者）
王熠明（内容创作者-Datawhale成员）
曾浩龙（内容创作者-Datawhale 意向成员-JLU AI 研究生）
小饭同学（内容创作者）
孙韩玉（内容创作者-算法量化部署工程师）
张银晗（内容创作者-Datawhale成员）
张晋（内容创作者-Datawhale成员）
李娇娇（内容创作者-Datawhale成员）
邓恺俊（内容创作者-Datawhale成员）
范致远（内容创作者-Datawhale成员）
周景林（内容创作者-Datawhale成员）
诸世纪（内容创作者-算法工程师）
Zhang Yixin（内容创作者-IT爱好者）
Sarai（内容创作者-AI应用爱好者）

其他

特别感谢 @Sm1les、@LSGOMYP 对本项目的帮助与支持；
感谢 GithubDaily 提供的双语字幕；
如果有任何想法可以联系我们 DataWhale 也欢迎大家多多提出 issue；
特别感谢以下为教程做出贡献的同学！

Made with contrib.rocks.

Star History

关注我们

扫描下方二维码关注公众号：Datawhale

Datawhale 是一个专注于数据科学与 AI 领域的开源组织，汇集了众多领域院校和知名企业的优秀学习者，聚合了一群有开源精神和探索精神的团队成员。微信搜索公众号Datawhale可以加入我们。

LICENSE

本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。

LangChain 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)

GenAI_Agents

NirDiamant/GenAI_Agents

GenAI Agents: Comprehensive Repository for Development and Implementation 🚀

📫 Stay Updated!

Introduction

📚 Learn to Build Your First AI Agent

Related Projects

A Community-Driven Knowledge Hub

Key Features

GenAI Agent Implementations

🌱 Beginner-Friendly Agents

Overview 🔎

Implementation 🛠️

Overview 🔎

Implementation 🛠️

Overview 🔎

Implementation 🛠️

🔧 Framework Tutorial

Overview 🔎

Implementation 🛠️

Additional Resources 📚

Overview 🔎

Implementation 🛠️

Additional Resources 📚

🎓 Educational and Research Agents

Overview 🔎

Implementation 🛠️

Additional Resources 📚

Overview 🔎

Implementation 🛠️

Additional Resources 📚

Overview 🔎

Implementation 🛠️

Additional Resources 📚

💼 Business and Professional Agents

Overview 🔎

Implementation 🛠️

Overview 🔎

Implementation 🛠️

Overview 🔎

Implementation 🛠️

Overview 🔎

Implementation 🛠️

Additional Resources 📚

Overview 🔎

Implementation 🛠️

Additional Resources 📚

Overview 🔎

Implementation 🛠️

Additional Resources 📚

Overview 🔎

Implementation 🛠️

Additional Resources 📚

🎨 Creative and Content Generation Agents

Overview 🔎

Implementation 🛠️

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

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