Add Forensic_Candidate_Analyzer Notebook #705
Conversation
WalkthroughFive new Jupyter notebooks are introduced, each demonstrating a distinct AI-powered assistant or agent workflow using the PraisonAI framework and related APIs. The examples cover government services Q&A, cognitive multi-specialist reasoning, internet search integration, cybersecurity PoC validation, and a real estate chatbot, each with custom logic, agent classes, and interactive user interfaces. Changes
Sequence Diagram(s)sequenceDiagram
participant User
participant Agent
participant Tool/API
User->>Agent: Enter query (via notebook UI)
Agent->>Tool/API: Invoke relevant tool or API (e.g., Firecrawl, DuckDuckGo, specialist, validation)
Tool/API-->>Agent: Return results or processed data
Agent-->>User: Generate and display response (possibly with translation)
Suggested labels
Poem
Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. 🪧 TipsChatThere are 3 ways to chat with CodeRabbit:
SupportNeed help? Create a ticket on our support page for assistance with any issues or questions. Note: Be mindful of the bot's finite context window. It's strongly recommended to break down tasks such as reading entire modules into smaller chunks. For a focused discussion, use review comments to chat about specific files and their changes, instead of using the PR comments. CodeRabbit Commands (Invoked using PR comments)
Other keywords and placeholders
CodeRabbit Configuration File (
|
![gemini-code-assist[bot]](https://avatars.githubusercontent.com/in/956858?s=60&v=4){kind=small}
There was a problem hiding this comment.
Summary of Changes
Hello @Dhivya-Bharathy, I'm Gemini Code Assist1! I'm currently reviewing this pull request and will post my feedback shortly. In the meantime, here's a summary to help you and other reviewers quickly get up to speed!
This pull request introduces five new cookbook examples demonstrating various use cases of PraisonAI agents, including a Chile government services assistant, an intelligent cognitive agent, a memory pal search agent, a cybersecurity PoC agent, and a real estate chatbot. These notebooks provide practical examples and showcase the versatility of PraisonAI in different domains.
Highlights
- New Notebook: Chile Government Services Assistant: Adds a new notebook demonstrating an AI-powered assistant for answering questions about Chilean government services, using the Firecrawl API and translation tools.
- New Notebook: Intelligent Cognitive Agent: Introduces a notebook showcasing a multi-specialist cognitive assistant using PraisonAI, where each specialist is implemented as a tool.
- New Notebook: MemoryPal Search Agent: Adds a notebook providing a minimal example of using PraisonAI's Agent with a custom internet search tool (DuckDuckGo) in Python, ready for Google Colab.
- New Notebook: Pocky Cybersecurity PoC Agent: Introduces a notebook for automated CVE PoC search and validation, using Exa and OpenAI for finding, filtering, and fetching real-world PoC exploits.
- New Notebook: Praison AI Real Estate Chatbot: Adds a notebook demonstrating a real estate AI assistant powered by PraisonAI and OpenAI, providing helpful advice on real estate questions.
Using Gemini Code Assist
The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.
Invoking Gemini
You can request assistance from Gemini at any point in your pull request via creating an issue comment (i.e. comment on the pull request page) using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands.
| Feature | Command | Description |
|---|---|---|
| Code Review | /gemini review |
Performs a code review for the current pull request in its current state. |
| Pull Request Summary | /gemini summary |
Provides a summary of the current pull request in its current state. |
| Comment | @gemini-code-assist | Responds in comments when explicitly tagged, both in issue comments and review comments. |
| Help | /gemini help |
Displays a list of available commands. |
Customization
To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.
Limitations & Feedback
Gemini Code Assist is currently in preview and may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments to provide feedback.
You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.
Footnotes
-
Review the Privacy Notices, Generative AI Prohibited Use Policy, Terms of Service, and learn how to configure Gemini Code Assist in GitHub here. Gemini can make mistakes, so double check it and use code with caution. ↩
Codecov ReportAll modified and coverable lines are covered by tests ✅
Additional details and impacted files@@ Coverage Diff @@
## main #705 +/- ##
=======================================
Coverage 14.50% 14.50%
=======================================
Files 25 25
Lines 2517 2517
Branches 357 357
=======================================
Hits 365 365
Misses 2136 2136
Partials 16 16
Flags with carried forward coverage won't be shown. Click here to find out more. ☔ View full report in Codecov by Sentry. 🚀 New features to boost your workflow:
|
There was a problem hiding this comment.
Code Review
This pull request adds several new example notebooks demonstrating the capabilities of the PraisonAI framework. The most critical issue is the use of hardcoded API key placeholders in the notebooks, which poses a security risk. I've also provided suggestions to improve code efficiency and maintainability.
| "os.environ['FIRECRAWL_API_KEY'] = \"your api key here\"\n", | ||
| "os.environ['OPENAI_API_KEY'] = \"your api key here\"" |
There was a problem hiding this comment.
Hardcoding API keys is a critical security risk. Use python-dotenv to load keys from a .env file or Colab secrets manager to prevent accidental exposure.
from google.colab import userdata
import os
os.environ['FIRECRAWL_API_KEY'] = userdata.get('FIRECRAWL_API_KEY')
os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')
| "import os\n", | ||
| "\n", | ||
| "# Set your OpenAI or OpenRouter API key for PraisonAI\n", | ||
| "os.environ['OPENAI_API_KEY'] = 'Enter your api key' # <-- Replace with your actual OpenAI or OpenRouter API key" |
There was a problem hiding this comment.
Hardcoding API keys is a critical security risk. Use Colab secrets manager or a .env file for local development.
os.environ['OPENAI_API_KEY'] = 'Enter your api key' # <-- Replace with your actual OpenAI or OpenRouter API key
| "import os\n", | ||
| "\n", | ||
| "# Enter your OpenAI API key here\n", | ||
| "os.environ['OPENAI_API_KEY'] = 'Enter your api key' # <-- Replace with your OpenAI API key" |
There was a problem hiding this comment.
Hardcoding API keys is a critical security risk. Use Colab secrets manager or a .env file for local development.
os.environ['OPENAI_API_KEY'] = 'Enter your api key' # <-- Replace with your OpenAI API key
| "os.environ[\"EXA_API_KEY\"] = \"your api key\"\n", | ||
| "os.environ[\"OPENAI_API_KEY\"] = \"your api key\"\n", | ||
| "os.environ[\"OPENAI_BASE_URL\"] = \"https://api.openai.com/v1\" # Optional, for custom OpenAI endpoints" |
There was a problem hiding this comment.
Hardcoding API keys is a critical security risk. Use Colab secrets manager or a .env file for local development.
| "OPENAI_API_KEY = \"Enter your api key here\" # <-- Replace with your key\n", | ||
| "os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY" |
There was a problem hiding this comment.
Hardcoding API keys is a critical security risk. Use Colab secrets manager or a .env file for local development.
OPENAI_API_KEY = "Enter your api key here" # <-- Replace with your key
os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
| "def translate_to_spanish(text):\n", | ||
| " try:\n", | ||
| " return GoogleTranslator(source='auto', target='es').translate(text)\n", | ||
| " except Exception as e:\n", | ||
| " print(\"Translation to Spanish failed:\", e)\n", | ||
| " return text\n", | ||
| "\n", | ||
| "def translate_to_english(text):\n", | ||
| " try:\n", | ||
| " # Remove Markdown images and None values before translation\n", | ||
| " text = str(text).replace(\"None\", \"\")\n", | ||
| " text = re.sub(r'!\\[.*?\\]\\(.*?\\)', '', text)\n", | ||
| " return GoogleTranslator(source='auto', target='en').translate(text)\n", | ||
| " except Exception as e:\n", | ||
| " print(\"Translation to English failed:\", e)\n", | ||
| " return text" | ||
| ] |
There was a problem hiding this comment.
Instantiating GoogleTranslator inside the translation functions is inefficient. Create translator instances once outside the functions and reuse them.
spanish_translator = GoogleTranslator(source='auto', target='es')
english_translator = GoogleTranslator(source='auto', target='en')
def translate_to_spanish(text):
try:
return spanish_translator.translate(text)
except Exception as e:
print("Translation to Spanish failed:", e)
return text
def translate_to_english(text):
try:
text = str(text).replace("None", "")
text = re.sub(r'!\[.*?\]\(.*?\)', '', text)
return english_translator.translate(text)
except Exception as e:
print("Translation to English failed:", e)
return text
| " self.template = template\n", | ||
| "\n", | ||
| " def search(self, search: str) -> str:\n", | ||
| " if not search or len(search) < 5:\n", |
There was a problem hiding this comment.
The function search can return None but is type-hinted to return a str. Update the type hint to Optional[str] for clarity.
def search(self, search: str) -> Optional[str]:
| "def internet_search_tool(query: str):\n", | ||
| " results = []\n", | ||
| " ddgs = DDGS()\n", | ||
| " for result in ddgs.text(keywords=query, max_results=5):\n", | ||
| " results.append({\n", | ||
| " 'title': result.get('title', ''),\n", | ||
| " 'url': result.get('href', ''),\n", | ||
| " 'snippet': result.get('body', '')\n", | ||
| " })\n", | ||
| " return results" |
There was a problem hiding this comment.
Instantiating DDGS() inside internet_search_tool on every call is inefficient. Create the DDGS instance once outside the function and reuse it.
from duckduckgo_search import DDGS
ddgs = DDGS()
def internet_search_tool(query: str):
results = []
for result in ddgs.text(keywords=query, max_results=5):
results.append({
'title': result.get('title', ''),
'url': result.get('href', ''),
'snippet': result.get('body', '')
})
return results
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 8
🧹 Nitpick comments (8)
examples/cookbooks/Pocky_Cybersecurity_PoC_Agent.ipynb (1)
174-190: Enhance the demonstration with more realistic simulation.The current simulation is too simplistic and doesn't showcase the intended workflow effectively.
Consider enhancing the demo:
def run_pocky_for_cve(cve_id): - # Example: Simulate fetching a description and PoC (replace with real logic) - description = f"Description for {cve_id} (replace with real Exa/OpenAI search)" - poc_sample = f"PoC code for {cve_id} (replace with real PoC search)" + # Example: More realistic simulation with sample CVE data + sample_descriptions = { + "CVE-2023-4450": "Buffer overflow vulnerability in XYZ application allowing remote code execution", + "CVE-2024-1234": "SQL injection vulnerability in web application login form" + } + sample_pocs = { + "CVE-2023-4450": "curl -X POST http://target.com/exploit -d 'payload=AAAA...'", + "CVE-2024-1234": "' OR '1'='1' -- " + } + + description = sample_descriptions.get(cve_id, f"Sample description for {cve_id}") + poc_sample = sample_pocs.get(cve_id, f"Sample PoC for {cve_id}") + + print(f"🔍 Analyzing CVE: {cve_id}") + print(f"📄 Description: {description}") + print(f"💻 PoC Sample: {poc_sample}")examples/cookbooks/Intelligent_Cognitive_Agent.ipynb (2)
131-137: Improve tool name sanitization robustness.The current sanitization approach may not handle edge cases effectively.
Enhance the sanitization logic:
def make_tool(agent): def tool(query: str): return agent.run(query) # Sanitize the tool name to match PraisonAI's requirements - safe_name = re.sub(r'[^a-zA-Z0-9_-]', '_', agent.name or "tool") + safe_name = re.sub(r'[^a-zA-Z0-9_]', '_', agent.name or "specialist_tool") + # Ensure the name starts with a letter and doesn't end with underscores + safe_name = re.sub(r'^[^a-zA-Z]*', '', safe_name) + safe_name = safe_name.rstrip('_') or "specialist_tool" tool.__name__ = safe_name + tool.__doc__ = f"Specialist tool for {agent.name} cognitive domain" return tool
95-111: Enhance specialist agent implementations for better demonstration.The current dummy implementations are too simplistic to showcase the cognitive assistant concept effectively.
Consider more sophisticated placeholder logic:
class SpecialistAgent: def __init__(self, name): self.name = name + self.expertise = self._get_expertise_description() + + def _get_expertise_description(self): + expertise_map = { + "decision_risk_agent": "risk assessment, decision matrices, probability analysis", + "problem_solving_innovation_agent": "creative problem solving, innovation frameworks, lateral thinking", + "Systems___Complexity_Agent": "systems thinking, complexity analysis, interdependency mapping", + "bias_psychology_agent": "cognitive biases, psychological patterns, behavioral analysis", + # Add more mappings... + } + return expertise_map.get(self.name, "general cognitive assistance") + def run(self, query): - return f"{self.name} specialist response to: {query}" + return f""" +🧠 {self.name.replace('_', ' ').title()} Analysis: + +Expertise: {self.expertise} + +Query Analysis: {query} + +Specialist Response: [This would be a detailed analysis using {self.expertise} principles. In a real implementation, this would contain domain-specific insights and recommendations.] + +Key Considerations: [Domain-specific factors to consider] +Recommended Actions: [Specific next steps based on specialist knowledge] + """.strip()examples/cookbooks/Praison_AI_Real_Estate_Chatbot.ipynb (1)
451-463: Enhance the user interface for better experience.The current UI is functional but could be improved for better user experience.
Consider enhancing the interface:
question = widgets.Text( value='', placeholder='Type your real estate question here...', description='You:', - disabled=False + disabled=False, + layout=widgets.Layout(width='500px') ) -button = widgets.Button(description="Ask Praison AI") +button = widgets.Button( + description="Ask Praison AI", + button_style='primary', + layout=widgets.Layout(width='200px') +) + +# Add a clear button for better UX +clear_button = widgets.Button( + description="Clear", + button_style='warning', + layout=widgets.Layout(width='100px') +) def on_button_clicked(b): ask_agent(question.value) + +def on_clear_clicked(b): + question.value = '' button.on_click(on_button_clicked) -display(question, button) +clear_button.on_click(on_clear_clicked) + +# Display in a more organized layout +input_box = widgets.HBox([question, button, clear_button]) +display(input_box)examples/cookbooks/Chile_Government_Services_Assistant.ipynb (1)
101-109: Enhance translation error handling robustness.The translation functions have good error handling, but could be more robust for edge cases.
Consider these improvements:
def translate_to_english(text): try: + # Handle empty or None input + if not text or str(text).strip() == "": + return text + # Remove Markdown images and None values before translation text = str(text).replace("None", "") text = re.sub(r'!\\[.*?\\]\\(.*?\\)', '', text) + + # Skip translation if text is too short or already in English + if len(text.strip()) < 3: + return text + return GoogleTranslator(source='auto', target='en').translate(text) except Exception as e: - print("Translation to English failed:", e) + print(f"Translation to English failed for text length {len(str(text))}: {e}") return textexamples/cookbooks/MemoryPal_Search_Agent.ipynb (3)
63-63: Make the API key setup instruction more explicit.The placeholder text could be clearer about what users need to do. Consider making it more obvious that users must replace this with their actual API key.
-os.environ['OPENAI_API_KEY'] = 'Enter your api key' # <-- Replace with your OpenAI API key +os.environ['OPENAI_API_KEY'] = 'your-actual-openai-api-key-here' # <-- REQUIRED: Replace with your actual OpenAI API key
126-145: Clarify the purpose of the YAML configuration section.The YAML configuration is shown but not used in the actual execution, which might confuse users about whether it's required for the agent to work.
Add a clarifying comment in the markdown cell:
# YAML Agent Config + +**Note**: This YAML configuration demonstrates PraisonAI's configuration format but is not required for this example. The agent is configured directly in Python code below.
477-481: Consider adding response validation.While the current implementation works, adding basic validation for the agent response could improve robustness.
# Main: Ask a question query = 'AI job trends in 2025' # You can change this prompt response = agent.start(query) + +if not response: + print("No response received from agent") +else: + print('Response:') + print(response) -print('Response:') -print(response)
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (5)
examples/cookbooks/Chile_Government_Services_Assistant.ipynb(1 hunks)examples/cookbooks/Intelligent_Cognitive_Agent.ipynb(1 hunks)examples/cookbooks/MemoryPal_Search_Agent.ipynb(1 hunks)examples/cookbooks/Pocky_Cybersecurity_PoC_Agent.ipynb(1 hunks)examples/cookbooks/Praison_AI_Real_Estate_Chatbot.ipynb(1 hunks)
🧰 Additional context used
🧠 Learnings (4)
📓 Common learnings
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-agents/CLAUDE.md:0-0
Timestamp: 2025-06-24T05:58:06.542Z
Learning: All major components (agents, workflows, tasks) in the PraisonAI Agents framework support asynchronous execution using Python's async/await syntax.
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-agents/CLAUDE.md:0-0
Timestamp: 2025-06-24T05:58:06.542Z
Learning: Multi-agent workflows in praisonaiagents/agents/ (Python) should use PraisonAIAgents to orchestrate agents and tasks, supporting sequential, hierarchical, and parallel processes, with optional manager agents for hierarchical flows.
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-ts/.cursorrules:0-0
Timestamp: 2025-06-24T05:57:49.389Z
Learning: The PraisonAIAgents class (in src/agents/agents.ts) is responsible for managing multiple agents, tasks, memory, process type, and acts as the orchestrator for agent interactions. It should accept configuration options for verbosity, completion checking, retries, process type, memory, and embedding.
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-ts/.windsurfrules:0-0
Timestamp: 2025-06-24T05:58:21.696Z
Learning: The PraisonAIAgents class should manage multiple agents, tasks, memory, process type, and other configurations, acting as the orchestrator for agent and task interactions. It should support process types such as sequential, workflow, and hierarchical.
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-agents/CLAUDE.md:0-0
Timestamp: 2025-06-24T05:58:06.542Z
Learning: When defining an Agent in praisonaiagents/agent/ (Python), always provide parameters for name, role, goal, backstory, LLM selection, self-reflection (with min/max iterations), optional tools, and guardrail logic (function or string) with a retry limit.
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-ts/.windsurfrules:0-0
Timestamp: 2025-06-24T05:58:21.696Z
Learning: In the TypeScript/Node.js version of PraisonAI Agents, all references to LLM or litellm should be replaced with aisdk usage for large language model calls. The LLM class in src/llm/llm.ts should wrap aisdk.generateText and provide a response method for agent and task usage.
examples/cookbooks/Praison_AI_Real_Estate_Chatbot.ipynb (2)
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-ts/.windsurfrules:0-0
Timestamp: 2025-06-24T05:58:21.696Z
Learning: In the TypeScript/Node.js version of PraisonAI Agents, all references to LLM or litellm should be replaced with aisdk usage for large language model calls. The LLM class in src/llm/llm.ts should wrap aisdk.generateText and provide a response method for agent and task usage.
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-ts/.cursorrules:0-0
Timestamp: 2025-06-24T05:57:49.389Z
Learning: In the TypeScript/Node.js version of PraisonAI Agents, all references to LLM or litellm should be replaced with aisdk usage for large language model calls. The LLM class in src/llm/llm.ts should wrap aisdk.generateText and provide a response method that returns a Promise<string>.
examples/cookbooks/Intelligent_Cognitive_Agent.ipynb (7)
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-agents/CLAUDE.md:0-0
Timestamp: 2025-06-24T05:58:06.542Z
Learning: When defining an Agent in praisonaiagents/agent/ (Python), always provide parameters for name, role, goal, backstory, LLM selection, self-reflection (with min/max iterations), optional tools, and guardrail logic (function or string) with a retry limit.
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-ts/.cursorrules:0-0
Timestamp: 2025-06-24T05:57:49.389Z
Learning: The PraisonAIAgents class (in src/agents/agents.ts) is responsible for managing multiple agents, tasks, memory, process type, and acts as the orchestrator for agent interactions. It should accept configuration options for verbosity, completion checking, retries, process type, memory, and embedding.
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-ts/.windsurfrules:0-0
Timestamp: 2025-06-24T05:58:21.696Z
Learning: In the TypeScript/Node.js version of PraisonAI Agents, all references to LLM or litellm should be replaced with aisdk usage for large language model calls. The LLM class in src/llm/llm.ts should wrap aisdk.generateText and provide a response method for agent and task usage.
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-agents/CLAUDE.md:0-0
Timestamp: 2025-06-24T05:58:06.542Z
Learning: Multi-agent workflows in praisonaiagents/agents/ (Python) should use PraisonAIAgents to orchestrate agents and tasks, supporting sequential, hierarchical, and parallel processes, with optional manager agents for hierarchical flows.
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-agents/CLAUDE.md:0-0
Timestamp: 2025-06-24T05:58:06.542Z
Learning: When implementing tools in praisonaiagents/tools/ (Python), use either the @tool decorator for simple function-based tools or subclass BaseTool for more complex tools.
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-ts/.windsurfrules:0-0
Timestamp: 2025-06-24T05:58:21.696Z
Learning: The PraisonAIAgents class should manage multiple agents, tasks, memory, process type, and other configurations, acting as the orchestrator for agent and task interactions. It should support process types such as sequential, workflow, and hierarchical.
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-ts/.cursorrules:0-0
Timestamp: 2025-06-24T05:57:49.389Z
Learning: In the TypeScript/Node.js version of PraisonAI Agents, all references to LLM or litellm should be replaced with aisdk usage for large language model calls. The LLM class in src/llm/llm.ts should wrap aisdk.generateText and provide a response method that returns a Promise<string>.
examples/cookbooks/MemoryPal_Search_Agent.ipynb (4)
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-agents/CLAUDE.md:0-0
Timestamp: 2025-06-24T05:58:06.542Z
Learning: When defining an Agent in praisonaiagents/agent/ (Python), always provide parameters for name, role, goal, backstory, LLM selection, self-reflection (with min/max iterations), optional tools, and guardrail logic (function or string) with a retry limit.
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-ts/.windsurfrules:0-0
Timestamp: 2025-06-24T05:58:21.696Z
Learning: In the TypeScript/Node.js version of PraisonAI Agents, all references to LLM or litellm should be replaced with aisdk usage for large language model calls. The LLM class in src/llm/llm.ts should wrap aisdk.generateText and provide a response method for agent and task usage.
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-ts/.cursorrules:0-0
Timestamp: 2025-06-24T05:57:49.389Z
Learning: The PraisonAIAgents class (in src/agents/agents.ts) is responsible for managing multiple agents, tasks, memory, process type, and acts as the orchestrator for agent interactions. It should accept configuration options for verbosity, completion checking, retries, process type, memory, and embedding.
Learnt from: CR
PR: MervinPraison/PraisonAI#0
File: src/praisonai-ts/.cursorrules:0-0
Timestamp: 2025-06-24T05:57:49.389Z
Learning: In the TypeScript/Node.js version of PraisonAI Agents, all references to LLM or litellm should be replaced with aisdk usage for large language model calls. The LLM class in src/llm/llm.ts should wrap aisdk.generateText and provide a response method that returns a Promise<string>.
⏰ Context from checks skipped due to timeout of 90000ms (5)
- GitHub Check: quick-test
- GitHub Check: test-core (3.11)
- GitHub Check: performance-test
- GitHub Check: test-examples
- GitHub Check: Run tests and collect coverage
🔇 Additional comments (6)
examples/cookbooks/Pocky_Cybersecurity_PoC_Agent.ipynb (1)
20-28: Verify the PR scope discrepancy.The PR objectives mention a "Forensic_Candidate_Analyzer Notebook" but the actual files include cybersecurity PoC validation, cognitive assistant, real estate chatbot, and government services assistant notebooks. Please confirm this is the intended scope.
Likely an incorrect or invalid review comment.
examples/cookbooks/Praison_AI_Real_Estate_Chatbot.ipynb (1)
446-450: Verify the agent interaction method.The comment mentions using
.chat()method for the "public praisonaiagents package" - ensure this is the correct method for the current PraisonAI version.Check if
.chat()is the correct method:#!/bin/bash # Search for agent interaction methods in PraisonAI documentation and examples rg -A 3 -B 3 "\.chat\(" --type py rg -A 3 -B 3 "\.start\(" --type pyexamples/cookbooks/Chile_Government_Services_Assistant.ipynb (2)
129-169: Excellent error handling and URL filtering implementation.The FirecrawlTool class demonstrates good practices with comprehensive error handling and appropriate URL filtering for the Chilean government domain.
264-282: Well-implemented user interaction flow.The main chat loop effectively handles translation, error cases, and provides good user feedback. The bilingual approach is well-designed for the Chilean government services use case.
examples/cookbooks/MemoryPal_Search_Agent.ipynb (2)
472-475: Agent configuration follows PraisonAI patterns correctly.The agent instantiation with instructions and tools aligns well with the PraisonAI framework patterns. The approach of passing custom tools to the agent constructor is consistent with the framework's design.
20-20: Verify the Colab badge URL points to the correct repository.The Colab badge references
DhivyaBharathy-web/PraisonAIbut according to the PR objectives, this should likely point toMervinPraison/PraisonAI.#!/bin/bash # Check if the repository path in the Colab badge matches the actual repository structure echo "Checking repository structure..." fd -t f "MemoryPal_Search_Agent.ipynb" examples/cookbooks/ 2>/dev/null || echo "File not found in expected location" # Check the repository name in git config echo "Current repository remote:" git remote get-url origin 2>/dev/null || echo "No git remote found"
| "# Dummy/Minimal agent classes for notebook demo\n", | ||
| "class ValidationAgent:\n", | ||
| " def __init__(self, input_json):\n", | ||
| " self.input_json = input_json\n", | ||
| " def run(self):\n", | ||
| " # Dummy validation logic for notebook demo\n", | ||
| " data = json.loads(self.input_json)\n", | ||
| " return True if \"attack_intent\" in data and \"poc_sample\" in data else False\n", | ||
| "\n", | ||
| "class AttackIntentAgent:\n", | ||
| " def __init__(self, description):\n", | ||
| " self.description = description\n", | ||
| " def run(self):\n", | ||
| " # Dummy intent extraction for notebook demo\n", | ||
| " return f\"Intent for: {self.description[:50]}...\"" |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Clarify that these are placeholder implementations.
The dummy agent classes might confuse users about the notebook's actual capabilities. Add clear documentation about their placeholder nature.
Add prominent documentation:
+# ⚠️ IMPORTANT: These are simplified placeholder implementations for demonstration only.
+# In a production environment, you would replace these with:
+# - Real CVE analysis logic
+# - Actual PoC validation algorithms
+# - Integration with security databases and tools
+
# Dummy/Minimal agent classes for notebook demo
class ValidationAgent:📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| "# Dummy/Minimal agent classes for notebook demo\n", | |
| "class ValidationAgent:\n", | |
| " def __init__(self, input_json):\n", | |
| " self.input_json = input_json\n", | |
| " def run(self):\n", | |
| " # Dummy validation logic for notebook demo\n", | |
| " data = json.loads(self.input_json)\n", | |
| " return True if \"attack_intent\" in data and \"poc_sample\" in data else False\n", | |
| "\n", | |
| "class AttackIntentAgent:\n", | |
| " def __init__(self, description):\n", | |
| " self.description = description\n", | |
| " def run(self):\n", | |
| " # Dummy intent extraction for notebook demo\n", | |
| " return f\"Intent for: {self.description[:50]}...\"" | |
| # ⚠️ IMPORTANT: These are simplified placeholder implementations for demonstration only. | |
| # In a production environment, you would replace these with: | |
| # - Real CVE analysis logic | |
| # - Actual PoC validation algorithms | |
| # - Integration with security databases and tools | |
| # Dummy/Minimal agent classes for notebook demo | |
| class ValidationAgent: | |
| def __init__(self, input_json): | |
| self.input_json = input_json | |
| def run(self): | |
| # Dummy validation logic for notebook demo | |
| data = json.loads(self.input_json) | |
| return True if "attack_intent" in data and "poc_sample" in data else False | |
| class AttackIntentAgent: | |
| def __init__(self, description): | |
| self.description = description | |
| def run(self): | |
| # Dummy intent extraction for notebook demo | |
| return f"Intent for: {self.description[:50]}..." |
🤖 Prompt for AI Agents
In examples/cookbooks/Pocky_Cybersecurity_PoC_Agent.ipynb around lines 104 to
118, the dummy agent classes lack clear documentation indicating they are
placeholders. Add prominent comments or docstrings at the start of each class to
explicitly state these are minimal, dummy implementations meant only for
demonstration and do not represent full functionality.
| "os.environ[\"EXA_API_KEY\"] = \"your api key\"\n", | ||
| "os.environ[\"OPENAI_API_KEY\"] = \"your api key\"\n", | ||
| "os.environ[\"OPENAI_BASE_URL\"] = \"https://api.openai.com/v1\" # Optional, for custom OpenAI endpoints" |
There was a problem hiding this comment.
Remove or secure hardcoded API key placeholders.
Exposing placeholder API keys in notebooks, even as examples, can lead to security issues if users accidentally commit real keys.
Replace with more secure approach:
-os.environ["EXA_API_KEY"] = "your api key"
-os.environ["OPENAI_API_KEY"] = "your api key"
-os.environ["OPENAI_BASE_URL"] = "https://api.openai.com/v1" # Optional, for custom OpenAI endpoints
+# Set your API keys here (replace with your actual keys)
+# os.environ["EXA_API_KEY"] = "your_actual_exa_api_key"
+# os.environ["OPENAI_API_KEY"] = "your_actual_openai_api_key"
+# os.environ["OPENAI_BASE_URL"] = "https://api.openai.com/v1" # Optional, for custom OpenAI endpoints
+
+# For Colab users, use getpass for secure input:
+# import getpass
+# os.environ["EXA_API_KEY"] = getpass.getpass("Enter your Exa API key: ")
+# os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter your OpenAI API key: ")📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| "os.environ[\"EXA_API_KEY\"] = \"your api key\"\n", | |
| "os.environ[\"OPENAI_API_KEY\"] = \"your api key\"\n", | |
| "os.environ[\"OPENAI_BASE_URL\"] = \"https://api.openai.com/v1\" # Optional, for custom OpenAI endpoints" | |
| # Set your API keys here (replace with your actual keys) | |
| # os.environ["EXA_API_KEY"] = "your_actual_exa_api_key" | |
| # os.environ["OPENAI_API_KEY"] = "your_actual_openai_api_key" | |
| # os.environ["OPENAI_BASE_URL"] = "https://api.openai.com/v1" # Optional, for custom OpenAI endpoints | |
| # For Colab users, use getpass for secure input: | |
| # import getpass | |
| # os.environ["EXA_API_KEY"] = getpass.getpass("Enter your Exa API key: ") | |
| # os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter your OpenAI API key: ") |
🤖 Prompt for AI Agents
In examples/cookbooks/Pocky_Cybersecurity_PoC_Agent.ipynb around lines 78 to 80,
the code hardcodes API key placeholders directly in environment variables, which
risks accidental exposure. Remove these hardcoded keys and instead instruct
users to set their API keys securely outside the notebook, such as through
environment variables in their system or using a secure secrets manager. Update
the notebook comments to guide users on securely providing their API keys
without embedding them in the code.
| "agent = Agent(\n", | ||
| " instructions=\"\"\"\n", | ||
| " You are a cognitive assistant with access to a set of specialist tools (decision making, problem solving, systems thinking, psychology, strategy, learning, efficiency, motivation).\n", | ||
| " Use the most relevant tool(s) to answer the user's query.\n", | ||
| " \"\"\",\n", | ||
| " tools=tools,\n", | ||
| ")" |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Align Agent creation with PraisonAI best practices.
According to the retrieved learnings, Agent instances should include parameters for name, role, goal, backstory, and other configurations.
Enhance the agent configuration:
agent = Agent(
+ name="Cognitive Assistant Team Lead",
+ role="Multi-Specialist Cognitive Assistant Coordinator",
+ goal="Provide comprehensive cognitive assistance by coordinating with specialist agents",
+ backstory="An experienced coordinator with access to multiple cognitive specialists, capable of determining the most appropriate expertise for each user query",
instructions="""
You are a cognitive assistant with access to a set of specialist tools (decision making, problem solving, systems thinking, psychology, strategy, learning, efficiency, motivation).
Use the most relevant tool(s) to answer the user's query.
+ Always explain which specialist(s) you're consulting and why they're relevant to the user's question.
""",
tools=tools,
+ verbose=True,
+ max_iter=3,
+ memory=True
)🤖 Prompt for AI Agents
In examples/cookbooks/Intelligent_Cognitive_Agent.ipynb around lines 141 to 147,
the Agent instantiation lacks key parameters such as name, role, goal, and
backstory required by PraisonAI best practices. Update the Agent creation to
include these parameters with appropriate descriptive values, ensuring the agent
is fully configured with name, role, goal, backstory, instructions, tools, and
any other necessary settings.
| "import os\n", | ||
| "\n", | ||
| "# Set your OpenAI or OpenRouter API key for PraisonAI\n", | ||
| "os.environ['OPENAI_API_KEY'] = 'Enter your api key' # <-- Replace with your actual OpenAI or OpenRouter API key" |
There was a problem hiding this comment.
Use secure API key input method.
Hardcoded API key placeholders pose security risks.
Apply the same secure approach as suggested for the previous notebook:
-os.environ['OPENAI_API_KEY'] = 'Enter your api key' # <-- Replace with your actual OpenAI or OpenRouter API key
+# Set your OpenAI or OpenRouter API key for PraisonAI
+# os.environ['OPENAI_API_KEY'] = 'your_actual_api_key'
+
+# For Colab users, use getpass for secure input:
+import getpass
+os.environ['OPENAI_API_KEY'] = getpass.getpass("Enter your OpenAI/OpenRouter API key: ")📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| "os.environ['OPENAI_API_KEY'] = 'Enter your api key' # <-- Replace with your actual OpenAI or OpenRouter API key" | |
| # Set your OpenAI or OpenRouter API key for PraisonAI | |
| # os.environ['OPENAI_API_KEY'] = 'your_actual_api_key' | |
| # For Colab users, use getpass for secure input: | |
| import getpass | |
| os.environ['OPENAI_API_KEY'] = getpass.getpass("Enter your OpenAI/OpenRouter API key: ") |
🤖 Prompt for AI Agents
In examples/cookbooks/Intelligent_Cognitive_Agent.ipynb at line 70, the API key
is hardcoded as a placeholder string, which is insecure. Replace this with a
secure input method such as using environment variables set outside the notebook
or prompting the user to input the API key at runtime without displaying it.
This approach prevents exposing the API key in the code and enhances security.
| "OPENAI_API_KEY = \"Enter your api key here\" # <-- Replace with your key\n", | ||
| "os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY" |
There was a problem hiding this comment.
Implement secure API key handling.
Same security concern as other notebooks with hardcoded placeholder keys.
Use the secure input approach:
-# Enter your OpenAI API key here
-OPENAI_API_KEY = "Enter your api key here" # <-- Replace with your key
-os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+# Enter your OpenAI API key securely
+import getpass
+OPENAI_API_KEY = getpass.getpass("Enter your OpenAI API key: ")
+os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| "OPENAI_API_KEY = \"Enter your api key here\" # <-- Replace with your key\n", | |
| "os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY" | |
| # Enter your OpenAI API key securely | |
| import getpass | |
| OPENAI_API_KEY = getpass.getpass("Enter your OpenAI API key: ") | |
| os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY |
🤖 Prompt for AI Agents
In examples/cookbooks/Praison_AI_Real_Estate_Chatbot.ipynb around lines 70 to
71, the API key is hardcoded as a placeholder string, which is insecure. Replace
this by prompting the user to securely input their API key at runtime using a
secure input method (e.g., getpass or input) instead of hardcoding it, then
assign it to the environment variable. This avoids exposing the key in the code.
| "praison_agent = Agent(\n", | ||
| " name=\"Praison Real Estate Chatbot\",\n", | ||
| " role=\"Answer real estate questions and provide helpful advice.\",\n", | ||
| " instructions=[\n", | ||
| " \"You are a helpful real estate assistant.\",\n", | ||
| " \"Answer user questions about buying, selling, or renting property.\",\n", | ||
| " \"Provide clear, concise, and friendly advice.\"\n", | ||
| " ],\n", | ||
| " markdown=True\n", | ||
| ")" |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Enhance Agent configuration with PraisonAI best practices.
The current agent configuration is basic and could benefit from following the framework's recommended patterns.
Improve the agent setup:
praison_agent = Agent(
name="Praison Real Estate Chatbot",
role="Answer real estate questions and provide helpful advice.",
+ goal="Provide accurate, helpful, and professional real estate guidance to users",
+ backstory="An experienced real estate professional with comprehensive knowledge of buying, selling, and renting properties. Specializes in first-time buyer guidance and market analysis.",
instructions=[
"You are a helpful real estate assistant.",
"Answer user questions about buying, selling, or renting property.",
- "Provide clear, concise, and friendly advice."
+ "Provide clear, concise, and friendly advice.",
+ "Always ask clarifying questions when needed to provide better assistance.",
+ "Include relevant market considerations and legal reminders when appropriate.",
+ "Suggest consulting with licensed professionals for complex legal or financial matters."
],
- markdown=True
+ markdown=True,
+ verbose=True,
+ memory=True,
+ max_iter=3
)📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| "praison_agent = Agent(\n", | |
| " name=\"Praison Real Estate Chatbot\",\n", | |
| " role=\"Answer real estate questions and provide helpful advice.\",\n", | |
| " instructions=[\n", | |
| " \"You are a helpful real estate assistant.\",\n", | |
| " \"Answer user questions about buying, selling, or renting property.\",\n", | |
| " \"Provide clear, concise, and friendly advice.\"\n", | |
| " ],\n", | |
| " markdown=True\n", | |
| ")" | |
| praison_agent = Agent( | |
| name="Praison Real Estate Chatbot", | |
| role="Answer real estate questions and provide helpful advice.", | |
| goal="Provide accurate, helpful, and professional real estate guidance to users", | |
| backstory="An experienced real estate professional with comprehensive knowledge of buying, selling, and renting properties. Specializes in first-time buyer guidance and market analysis.", | |
| instructions=[ | |
| "You are a helpful real estate assistant.", | |
| "Answer user questions about buying, selling, or renting property.", | |
| "Provide clear, concise, and friendly advice.", | |
| "Always ask clarifying questions when needed to provide better assistance.", | |
| "Include relevant market considerations and legal reminders when appropriate.", | |
| "Suggest consulting with licensed professionals for complex legal or financial matters." | |
| ], | |
| markdown=True, | |
| verbose=True, | |
| memory=True, | |
| max_iter=3 | |
| ) |
🤖 Prompt for AI Agents
In examples/cookbooks/Praison_AI_Real_Estate_Chatbot.ipynb around lines 93 to
102, the Agent configuration is too basic and does not follow PraisonAI best
practices. Enhance the agent setup by adding recommended parameters such as
specifying the model to use, setting temperature for response variability,
including relevant context or memory if supported, and refining instructions to
be more detailed and aligned with PraisonAI guidelines. This will improve the
agent's performance and adherence to the framework's standards.
| "os.environ['FIRECRAWL_API_KEY'] = \"your api key here\"\n", | ||
| "os.environ['OPENAI_API_KEY'] = \"your api key here\"" |
There was a problem hiding this comment.
Secure API key configuration.
Same security issue with hardcoded placeholder API keys.
Implement secure key input:
-os.environ['FIRECRAWL_API_KEY'] = "your api key here"
-os.environ['OPENAI_API_KEY'] = "your api key here"
+import getpass
+
+# Secure API key input
+os.environ['FIRECRAWL_API_KEY'] = getpass.getpass("Enter your Firecrawl API key: ")
+os.environ['OPENAI_API_KEY'] = getpass.getpass("Enter your OpenAI API key: ")📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| "os.environ['FIRECRAWL_API_KEY'] = \"your api key here\"\n", | |
| "os.environ['OPENAI_API_KEY'] = \"your api key here\"" | |
| import getpass | |
| # Secure API key input | |
| os.environ['FIRECRAWL_API_KEY'] = getpass.getpass("Enter your Firecrawl API key: ") | |
| os.environ['OPENAI_API_KEY'] = getpass.getpass("Enter your OpenAI API key: ") |
🤖 Prompt for AI Agents
In examples/cookbooks/Chile_Government_Services_Assistant.ipynb around lines 69
to 70, the API keys are hardcoded as plain text strings, which is insecure.
Replace these hardcoded keys by prompting the user to input the API keys
securely at runtime or load them from environment variables or a secure vault,
avoiding direct assignment in the code. This ensures the keys are not exposed in
the source code.
| "def internet_search_tool(query: str):\n", | ||
| " results = []\n", | ||
| " ddgs = DDGS()\n", | ||
| " for result in ddgs.text(keywords=query, max_results=5):\n", | ||
| " results.append({\n", | ||
| " 'title': result.get('title', ''),\n", | ||
| " 'url': result.get('href', ''),\n", | ||
| " 'snippet': result.get('body', '')\n", | ||
| " })\n", | ||
| " return results" |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Add error handling to the internet search tool.
The search function lacks error handling for network failures, API rate limits, or empty results, which could cause the agent to fail unexpectedly.
def internet_search_tool(query: str):
+ """Search the internet using DuckDuckGo and return structured results."""
+ if not query or not query.strip():
+ return []
+
results = []
- ddgs = DDGS()
- for result in ddgs.text(keywords=query, max_results=5):
- results.append({
- 'title': result.get('title', ''),
- 'url': result.get('href', ''),
- 'snippet': result.get('body', '')
- })
+ try:
+ ddgs = DDGS()
+ for result in ddgs.text(keywords=query, max_results=5):
+ results.append({
+ 'title': result.get('title', ''),
+ 'url': result.get('href', ''),
+ 'snippet': result.get('body', '')
+ })
+ except Exception as e:
+ print(f"Search error: {e}")
+ return [{"title": "Search Error", "url": "", "snippet": f"Failed to search: {str(e)}"}]
+
return results📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| "def internet_search_tool(query: str):\n", | |
| " results = []\n", | |
| " ddgs = DDGS()\n", | |
| " for result in ddgs.text(keywords=query, max_results=5):\n", | |
| " results.append({\n", | |
| " 'title': result.get('title', ''),\n", | |
| " 'url': result.get('href', ''),\n", | |
| " 'snippet': result.get('body', '')\n", | |
| " })\n", | |
| " return results" | |
| def internet_search_tool(query: str): | |
| """Search the internet using DuckDuckGo and return structured results.""" | |
| if not query or not query.strip(): | |
| return [] | |
| results = [] | |
| try: | |
| ddgs = DDGS() | |
| for result in ddgs.text(keywords=query, max_results=5): | |
| results.append({ | |
| 'title': result.get('title', ''), | |
| 'url': result.get('href', ''), | |
| 'snippet': result.get('body', '') | |
| }) | |
| except Exception as e: | |
| print(f"Search error: {e}") | |
| return [{"title": "Search Error", "url": "", "snippet": f"Failed to search: {str(e)}"}] | |
| return results |
🤖 Prompt for AI Agents
In examples/cookbooks/MemoryPal_Search_Agent.ipynb around lines 85 to 94, the
internet_search_tool function lacks error handling for network issues, API rate
limits, or empty results. Wrap the search logic in a try-except block to catch
exceptions, log or handle errors gracefully, and ensure the function returns an
empty list or a meaningful response if the search fails or yields no results.
This notebook provides a forensic, AI-powered analysis of tech candidates using their GitHub and LinkedIn profiles.
It leverages PraisonAI agents and custom tools to deliver strict, evidence-based talent evaluation and scoring.
Designed for recruiters and hiring managers seeking elite, data-driven technical screening in a Colab environment.
Summary by CodeRabbit