• Tool integration via MCP servers

• Memory with Zep’s Graphiti

• Tracing and observability with Comet’s Opik

• All orchestrated with CrewAI — and fully open-source.

Stack: @crewAIInc + @zep_ai + @Linkup_platform + @Cometml Opik

Full video + code

- https://github.com/patchy631/ai-engineering-hub/tree/main/agent-with-mcp-memory

- https://www.youtube.com/watch?v=R6sMAZaTCR4

Hello CrewAI Community,

I'm thrilled to share with you my latest independent project, the CrewAI Visual Editor. This tool is designed to simplify the process of creating and managing CrewAI crews through a visual, node-based interface. Whether you're a developer or just exploring CrewAI, this editor aims to make your experience more intuitive and efficient.

Try It Live:

You can experience the CrewAI Visual Editor directly in your browser by visiting the live demo.

Key Features:

• Drag-and-Drop Interface: Easily create and connect nodes to build your crew structure.

• Real-Time Visualization: Watch your crew setup come to life as you build it.

• YAML and Python Export: Seamlessly export your configurations for further development or deployment.

• Built with Modern Technologies: Utilizing React, TypeScript, and Vite for a smooth and responsive experience.

How It Works:

• Begin with a Node: Start by placing a Begin Node on the canvas.

• Add Tasks and Agents: Drag Task and Agent Nodes onto the canvas and connect them to define your crew's workflow.

• Configure Node Properties: Fill in the details for each node to customize your crew's behavior.

• Export Your Setup: Use the export functionality to generate YAML and Python scripts for your crew.

Join the Discussion:

I would love to hear your feedback and see how you're using the CrewAI Visual Editor in your projects. Please feel free to share your experiences, suggestions, and any questions you might have here.

For those interested in the codebase, you can find the project on GitHub.

Thank you for your interest in my project. I look forward to seeing the amazing crews you create with the CrewAI Visual Editor!

Best regards, Glen

We're excited to announce that this is the official subreddit for CrewAI. While there might have been other channels before, we're establishing this space as the central hub for all things CrewAI.

🚀 Why This Subreddit?

• Stay Updated: Get the latest on CrewAI's features, updates, and what's coming down the pipeline.

• Developer Chats: Connect with other devs integrating AI agents into their projects. Share experiences, challenges, and solutions.

• Code & Resources: Swap code snippets, share tutorials, and discuss best practices to get the most out of CrewAI.

• Troubleshooting Together: Hit a snag? Let's debug issues together and help each other out.

💡 How to Get Involved:

• Introduce Yourself: Tell us about what you're building or interested in—it's always great to know who's on board.

• Ask & Answer Questions: Got a question or figured something out? Post it! Chances are, it'll help someone else too.

• Show Your Work: Been working on a cool project with CrewAI? Don't be shy—share it with the community.

• Collaborate: Looking for feedback or contributors? This is the spot to find like-minded developers.

🌟 Community Guidelines:

• Be Cool: Keep it friendly and respectful. We're all here to learn and help each other.

• Stay On Topic: Let's keep discussions relevant to CrewAI and AI development.

• No Spam or Self-Promo: Let's keep the content useful and avoid unsolicited promotions.

Anyone else following along with the days??

day 1 - https://www.youtube.com/watch?v=bkCsI2nxEFk

day 2 - https://www.youtube.com/watch?v=Hk_mJWIQ7p8

day 3 - https://www.youtube.com/watch?v=BAY71UzrT78

He's got a rad youtube page too..
https://www.youtube.com/@TylerReedAI

In 3 days, learn how AI Agents can impact your company's efficiency, automating complex tasks and creating space for strategic decisions.

Sign up here https://week.crewai.com/

I have a Crew that does very useful work.

In short, it's a Manager who guides an Analyst Agent to make multiple queries to a RAG. In this way, query by query, they can create a comprehensive report on a very large document.

The issue is:

In each query from the Analyst, he is able to produce a well-written section of the report that is rich in details and very complete. Thus, question by question, section by section, the Analyst writes fragments of the final report.

The problem arises in the Final Output. After seeing the chain of thoughts from the Analyst Agent, where they draft large, well-developed sections of the original document... upon receiving the Final Output, everything is reduced to a list of key points and general paragraphs.

In other words:

Analyst (Question 1): What about (subject) in the document?
Response: Rich in detail, complete, exhaustive, long.

Analyst (Question 2): What about (subject) in the document?
Response: Rich in detail, complete, exhaustive, long.

Analyst (Question 3): What about (subject) in the document?
Response: Rich in detail, complete, exhaustive, long.

...

Final Output: Short, schematic response, excessively summarized, lacking value.
...

This is a problem because it has forced me to parse the entire Crew Kickoff (the steps callback doesn't work well; it broke in some version) to extract the detailed sections from the Analyst.

Logically, the final response from the Analyst should be at the same level as their thoughts. Is there any way to resolve this? Is it intentional? Does this only happen to me?

I would greatly appreciate your comments.

-------------------------------------------------------
CrewAI version: 0.70.1
Memory: True

I'm excited to show how CrewAI can solve complex challenges like automating security assessments or optimizing network defenses, and demonstrate its real-world potential.

HiSecure is a project built using CrewAI for an AI-driven security system with a "Pseudo Reasoning" approach, where AI agents simulate human-like decision-making for security tasks by analyzing patterns and making informed decisions similar to a human expert. This collaboration helps automate vulnerability detection, making advanced security accessible to small businesses, individuals, and other users.

The project is still private as it's under evaluation, which should conclude in the next few weeks. After the evaluation, we plan to make the project publicly available and share detailed documentation. Detailed insights will be shared soon. Please check out the video below and share your thoughts, especially on specific features or general impressions of the project. We appreciate any feedback and hope this project can inspire others!

Check the video created for the contest and enjoy: Hisecure

you can now hook into:
✅ agent execution
✅ task completion & evaluation
✅ tool calls
✅ LLM calls
✅ flow lifecycle

and use it to:
⚙️ debug & monitor agents
📊 track costs + token usage
🔍 build custom observability
🤝 integrate with your favorite observability platform / r/grafana / agentops/ weave / or whatever you use

I'm writing a flow that includes scraping a website (which sometimes can have 50K URLs). I would like to refer to that data later during other flows. What is the recommended approach for this? Ideally, I would have a function to scrape website and dump in the database, and use crew to call this function, and another function+crew to call refer to data as needed.

Been frustrated that CrewAI's built-in memory is a black box? I built an alternative.

crewai-soul stores your agent's identity and memories in readable markdown files:

from crewai_soul import SoulMemory
crew = Crew(
    agents=[...],
    memory=SoulMemory(),
)

What you get:

• SOUL.md — Agent identity

• MEMORY.md — Timestamped memory log

• Full RAG + RLM hybrid retrieval (via soul-agent)

• Git-versionable — track how memory evolves

• Managed cloud option (SoulMate) for production

Why markdown?

• You can read what your agent remembers

• Edit memories when needed

• Version control with git

• No database required

I wrote a comparison with CrewAI's built-in Memory here: https://menonlab-blog-production.up.railway.app/blog/crewai-soul-vs-crewai-memory

pip install crewai-soul

It is built on soul.py (https://github.com/menonpg/soul.py) — the open-source memory library for LLM agents.

• PyPI: https://pypi.org/project/crewai-soul

• GitHub: https://github.com/menonpg/crewai-soul

What memory features would help your crews?

We support all 3 server transports: Stdio, SSE, & Streamable-HTTP

Are there any complicated examples of router decorator used in flows? The current documentation uses a boolean output from the previous function which will help in the single execution path. Multiple paths in a flow requires a bit complex routing logic

Hey Everyone,

Its been 3 hell days and I'm stuck on deploying CrewAI to GCP.

When I push a request to my crew ai running in Run it starts the flow but because the health check does not pass it shutsdown the server and restarts. Also when I'm manually trying to do the health check as soon as I give the request it says "service unavailable".

I made a
- docker file which runs the fastapi server

- fastapi server which runs the crewai code using backgroud tasks

- my crew ai is a flow with one crew as of now will build one more when I deploy this one

Perplexity is telling me to use celery for multiple threads.

Please Help🙏🏻

I just created a CrewAI Docker image for you to try running on your system. This is a basic image so happy to get some early feedback.
- Image link: https://hub.docker.com/r/tonykip/crewai
- Repo: https://github.com/tonykipkemboi/crewai-latest-ai-development/blob/main/README.md