fix: widen OpenTelemetry version constraints to >=1.34.0,<2 (fixes #4474)

The opentelemetry-api, opentelemetry-sdk, and opentelemetry-exporter-otlp-proto-http
dependencies were pinned to ~=1.34.0 (>=1.34.0,<1.35.0), which conflicts with
google-adk and other libraries requiring >=1.36.0.

Widened to >=1.34.0,<2 to allow compatible newer versions while staying within
the stable 1.x API.

Co-Authored-By: João <joao@crewai.com>

.env.test

@@ -21,6 +21,7 @@ OPENROUTER_API_KEY=fake-openrouter-key
 AWS_ACCESS_KEY_ID=fake-aws-access-key
 AWS_SECRET_ACCESS_KEY=fake-aws-secret-key
 AWS_DEFAULT_REGION=us-east-1
+AWS_REGION_NAME=us-east-1
 
 # -----------------------------------------------------------------------------
 # Azure OpenAI Configuration

.github/workflows/publish.yml

@@ -1,6 +1,8 @@
 name: Publish to PyPI
 
 on:
+  repository_dispatch:
+    types: [deployment-tests-passed]
   workflow_dispatch:
     inputs:
       release_tag:
@@ -18,8 +20,11 @@ jobs:
       - name: Determine release tag
         id: release
         run: |
+          # Priority: workflow_dispatch input > repository_dispatch payload > default branch
           if [ -n "${{ inputs.release_tag }}" ]; then
             echo "tag=${{ inputs.release_tag }}" >> $GITHUB_OUTPUT
+          elif [ -n "${{ github.event.client_payload.release_tag }}" ]; then
+            echo "tag=${{ github.event.client_payload.release_tag }}" >> $GITHUB_OUTPUT
           else
             echo "tag=" >> $GITHUB_OUTPUT
           fi

.github/workflows/trigger-deployment-tests.yml

@@ -0,0 +1,18 @@
+name: Trigger Deployment Tests
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  trigger:
+    name: Trigger deployment tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Trigger deployment tests
+        uses: peter-evans/repository-dispatch@v3
+        with:
+          token: ${{ secrets.CREWAI_DEPLOYMENTS_PAT }}
+          repository: ${{ secrets.CREWAI_DEPLOYMENTS_REPOSITORY }}
+          event-type: crewai-release
+          client-payload: '{"release_tag": "${{ github.event.release.tag_name }}", "release_name": "${{ github.event.release.name }}"}'

.gitignore

@@ -27,6 +27,3 @@ conceptual_plan.md
 build_image
 chromadb-*.lock
 .claude
-.crewai/memory
-blogs/*
-secrets/*

conftest.py

@@ -11,11 +11,7 @@ from typing import Any
 from dotenv import load_dotenv
 import pytest
 from vcr.request import Request  # type: ignore[import-untyped]
-
-try:
-    import vcr.stubs.httpx_stubs as httpx_stubs  # type: ignore[import-untyped]
-except ModuleNotFoundError:
-    import vcr.stubs.httpcore_stubs as httpx_stubs  # type: ignore[import-untyped]
+import vcr.stubs.httpx_stubs as httpx_stubs  # type: ignore[import-untyped]
 
 
 env_test_path = Path(__file__).parent / ".env.test"

docs/en/changelog.mdx

@@ -4,106 +4,6 @@ description: "Product updates, improvements, and bug fixes for CrewAI"
 icon: "clock"
 mode: "wide"
 ---
-<Update label="Feb 27, 2026">
-  ## v1.10.1a1
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## What's Changed
-
-  ### Features
-  - Implement asynchronous invocation support in step callback methods
-  - Implement lazy loading for heavy dependencies in Memory module
-
-  ### Documentation
-  - Update changelog and version for v1.10.0
-
-  ### Refactoring
-  - Refactor step callback methods to support asynchronous invocation
-  - Refactor to implement lazy loading for heavy dependencies in Memory module
-
-  ### Bug Fixes
-  - Fix branch for release notes
-
-  ## Contributors
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
-<Update label="Feb 27, 2026">
-  ## v1.10.1a1
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## What's Changed
-
-  ### Refactoring
-  - Refactor step callback methods to support asynchronous invocation
-  - Implement lazy loading for heavy dependencies in Memory module
-
-  ### Documentation
-  - Update changelog and version for v1.10.0
-
-  ### Bug Fixes
-  - Make branch for release notes
-
-  ## Contributors
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
-<Update label="Feb 26, 2026">
-  ## v1.10.0
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.0)
-
-  ## What's Changed
-
-  ### Features
-  - Enhance MCP tool resolution and related events
-  - Update lancedb version and add lance-namespace packages
-  - Enhance JSON argument parsing and validation in CrewAgentExecutor and BaseTool
-  - Migrate CLI HTTP client from requests to httpx
-  - Add versioned documentation
-  - Add yanked detection for version notes
-  - Implement user input handling in Flows
-  - Enhance HITL self-loop functionality in human feedback integration tests
-  - Add started_event_id and set in eventbus
-  - Auto update tools.specs
-
-  ### Bug Fixes
-  - Validate tool kwargs even when empty to prevent cryptic TypeError
-  - Preserve null types in tool parameter schemas for LLM
-  - Map output_pydantic/output_json to native structured output
-  - Ensure callbacks are ran/awaited if promise
-  - Capture method name in exception context
-  - Preserve enum type in router result; improve types
-  - Fix cyclic flows silently breaking when persistence ID is passed in inputs
-  - Correct CLI flag format from --skip-provider to --skip_provider
-  - Ensure OpenAI tool call stream is finalized
-  - Resolve complex schema $ref pointers in MCP tools
-  - Enforce additionalProperties=false in schemas
-  - Reject reserved script names for crew folders
-  - Resolve race condition in guardrail event emission test
-
-  ### Documentation
-  - Add litellm dependency note for non-native LLM providers
-  - Clarify NL2SQL security model and hardening guidance
-  - Add 96 missing actions across 9 integrations
-
-  ### Refactoring
-  - Refactor crew to provider
-  - Extract HITL to provider pattern
-  - Improve hook typing and registration
-
-  ## Contributors
-
-  @dependabot[bot], @github-actions[bot], @github-code-quality[bot], @greysonlalonde, @heitorado, @hobostay, @joaomdmoura, @johnvan7, @jonathansampson, @lorenzejay, @lucasgomide, @mattatcha, @mplachta, @nicoferdi96, @theCyberTech, @thiagomoretto, @vinibrsl
-
-</Update>
-
 <Update label="Jan 26, 2026">
   ## v1.9.0
 

docs/en/concepts/flows.mdx

@@ -975,79 +975,6 @@ result = streaming.result
 
 Learn more about streaming in the [Streaming Flow Execution](/en/learn/streaming-flow-execution) guide.
 
-## Memory in Flows
-
-Every Flow automatically has access to CrewAI's unified [Memory](/concepts/memory) system. You can store, recall, and extract memories directly inside any flow method using three built-in convenience methods.
-
-### Built-in Methods
-
-| Method | Description |
-| :--- | :--- |
-| `self.remember(content, **kwargs)` | Store content in memory. Accepts optional `scope`, `categories`, `metadata`, `importance`. |
-| `self.recall(query, **kwargs)` | Retrieve relevant memories. Accepts optional `scope`, `categories`, `limit`, `depth`. |
-| `self.extract_memories(content)` | Break raw text into discrete, self-contained memory statements. |
-
-A default `Memory()` instance is created automatically when the Flow initializes. You can also pass a custom one:
-
-```python
-from crewai.flow.flow import Flow
-from crewai import Memory
-
-custom_memory = Memory(
-    recency_weight=0.5,
-    recency_half_life_days=7,
-    embedder={"provider": "ollama", "config": {"model_name": "mxbai-embed-large"}},
-)
-
-flow = MyFlow(memory=custom_memory)
-```
-
-### Example: Research and Analyze Flow
-
-```python
-from crewai.flow.flow import Flow, listen, start
-
-
-class ResearchAnalysisFlow(Flow):
-    @start()
-    def gather_data(self):
-        # Simulate research findings
-        findings = (
-            "PostgreSQL handles 10k concurrent connections with connection pooling. "
-            "MySQL caps at around 5k. MongoDB scales horizontally but adds complexity."
-        )
-
-        # Extract atomic facts and remember each one
-        memories = self.extract_memories(findings)
-        for mem in memories:
-            self.remember(mem, scope="/research/databases")
-
-        return findings
-
-    @listen(gather_data)
-    def analyze(self, raw_findings):
-        # Recall relevant past research (from this run or previous runs)
-        past = self.recall("database performance and scaling", limit=10, depth="shallow")
-
-        context_lines = [f"- {m.record.content}" for m in past]
-        context = "\n".join(context_lines) if context_lines else "No prior context."
-
-        return {
-            "new_findings": raw_findings,
-            "prior_context": context,
-            "total_memories": len(past),
-        }
-
-
-flow = ResearchAnalysisFlow()
-result = flow.kickoff()
-print(result)
-```
-
-Because memory persists across runs (backed by LanceDB on disk), the `analyze` step will recall findings from previous executions too -- enabling flows that learn and accumulate knowledge over time.
-
-See the [Memory documentation](/concepts/memory) for details on scopes, slices, composite scoring, embedder configuration, and more.
-
 ### Using the CLI
 
 Starting from version 0.103.0, you can run flows using the `crewai run` command:

docs/en/concepts/llms.mdx

@@ -106,15 +106,6 @@ There are different places in CrewAI code where you can specify the model to use
   </Tab>
 </Tabs>
 
-<Info>
-  CrewAI provides native SDK integrations for OpenAI, Anthropic, Google (Gemini API), Azure, and AWS Bedrock — no extra install needed beyond the provider-specific extras (e.g. `uv add "crewai[openai]"`).
-
-  All other providers are powered by **LiteLLM**. If you plan to use any of them, add it as a dependency to your project:
-  ```bash
-  uv add 'crewai[litellm]'
-  ```
-</Info>
-
 ## Provider Configuration Examples
 
 CrewAI supports a multitude of LLM providers, each offering unique features, authentication methods, and model capabilities.
@@ -284,11 +275,6 @@ In this section, you'll find detailed examples that help you select, configure,
     | `meta_llama/Llama-4-Maverick-17B-128E-Instruct-FP8` | 128k | 4028 | Text, Image | Text |
     | `meta_llama/Llama-3.3-70B-Instruct` | 128k | 4028 | Text | Text |
     | `meta_llama/Llama-3.3-8B-Instruct` | 128k | 4028 | Text | Text |
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Anthropic">
@@ -484,7 +470,7 @@ In this section, you'll find detailed examples that help you select, configure,
       To get an Express mode API key:
       - New Google Cloud users: Get an [express mode API key](https://cloud.google.com/vertex-ai/generative-ai/docs/start/quickstart?usertype=apikey)
       - Existing Google Cloud users: Get a [Google Cloud API key bound to a service account](https://cloud.google.com/docs/authentication/api-keys)
-
+      
       For more details, see the [Vertex AI Express mode documentation](https://docs.cloud.google.com/vertex-ai/generative-ai/docs/start/quickstart?usertype=apikey).
     </Info>
 
@@ -585,11 +571,6 @@ In this section, you'll find detailed examples that help you select, configure,
     | gemini-1.5-flash               | 1M tokens      | Balanced multimodal model, good for most tasks                    |
     | gemini-1.5-flash-8B            | 1M tokens      | Fastest, most cost-efficient, good for high-frequency tasks       |
     | gemini-1.5-pro                 | 2M tokens      | Best performing, wide variety of reasoning tasks including logical reasoning, coding, and creative collaboration |
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Azure">
@@ -671,7 +652,6 @@ In this section, you'll find detailed examples that help you select, configure,
     # Optional
     AWS_SESSION_TOKEN=<your-session-token>  # For temporary credentials
     AWS_DEFAULT_REGION=<your-region>  # Defaults to us-east-1
-    AWS_REGION_NAME=<your-region>  # Alternative configuration for backwards compatibility with LiteLLM. Defaults to us-east-1
     ```
 
     **Basic Usage:**
@@ -715,7 +695,6 @@ In this section, you'll find detailed examples that help you select, configure,
     - `AWS_SECRET_ACCESS_KEY`: AWS secret key (required)
     - `AWS_SESSION_TOKEN`: AWS session token for temporary credentials (optional)
     - `AWS_DEFAULT_REGION`: AWS region (defaults to `us-east-1`)
-    - `AWS_REGION_NAME`: AWS region (defaults to `us-east-1`). Alternative configuration for backwards compatibility with LiteLLM
 
     **Features:**
     - Native tool calling support via Converse API
@@ -785,11 +764,6 @@ In this section, you'll find detailed examples that help you select, configure,
         model="sagemaker/<my-endpoint>"
     )
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Mistral">
@@ -805,11 +779,6 @@ In this section, you'll find detailed examples that help you select, configure,
         temperature=0.7
     )
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Nvidia NIM">
@@ -896,11 +865,6 @@ In this section, you'll find detailed examples that help you select, configure,
     | rakuten/rakutenai-7b-instruct                                     | 1,024 tokens   | Advanced state-of-the-art LLM with language understanding, superior reasoning, and text generation. |
     | rakuten/rakutenai-7b-chat                                         | 1,024 tokens   | Advanced state-of-the-art LLM with language understanding, superior reasoning, and text generation. |
     | baichuan-inc/baichuan2-13b-chat                                  | 4,096 tokens   | Support Chinese and English chat, coding, math, instruction following, solving quizzes |
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Local NVIDIA NIM Deployed using WSL2">
@@ -941,11 +905,6 @@ In this section, you'll find detailed examples that help you select, configure,
 
         # ...
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Groq">
@@ -967,11 +926,6 @@ In this section, you'll find detailed examples that help you select, configure,
     | Llama 3.1 70B/8B  | 131,072 tokens   | High-performance, large context tasks      |
     | Llama 3.2 Series  | 8,192 tokens     | General-purpose tasks                      |
     | Mixtral 8x7B      | 32,768 tokens    | Balanced performance and context           |
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="IBM watsonx.ai">
@@ -994,11 +948,6 @@ In this section, you'll find detailed examples that help you select, configure,
         base_url="https://api.watsonx.ai/v1"
     )
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Ollama (Local LLMs)">
@@ -1012,11 +961,6 @@ In this section, you'll find detailed examples that help you select, configure,
         base_url="http://localhost:11434"
     )
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Fireworks AI">
@@ -1032,11 +976,6 @@ In this section, you'll find detailed examples that help you select, configure,
         temperature=0.7
     )
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Perplexity AI">
@@ -1052,11 +991,6 @@ In this section, you'll find detailed examples that help you select, configure,
         base_url="https://api.perplexity.ai/"
     )
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Hugging Face">
@@ -1071,11 +1005,6 @@ In this section, you'll find detailed examples that help you select, configure,
         model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct"
     )
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="SambaNova">
@@ -1099,11 +1028,6 @@ In this section, you'll find detailed examples that help you select, configure,
     | Llama 3.2 Series   | 8,192 tokens           | General-purpose, multimodal tasks            |
     | Llama 3.3 70B      | Up to 131,072 tokens   | High-performance and output quality          |
     | Qwen2 familly      | 8,192 tokens           | High-performance and output quality          |
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Cerebras">
@@ -1129,11 +1053,6 @@ In this section, you'll find detailed examples that help you select, configure,
       - Good balance of speed and quality
       - Support for long context windows
     </Info>
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Open Router">
@@ -1156,11 +1075,6 @@ In this section, you'll find detailed examples that help you select, configure,
       - openrouter/deepseek/deepseek-r1
       - openrouter/deepseek/deepseek-chat
     </Info>
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Nebius AI Studio">
@@ -1183,11 +1097,6 @@ In this section, you'll find detailed examples that help you select, configure,
       - Competitive pricing
       - Good balance of speed and quality
     </Info>
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 </AccordionGroup>
 

docs/en/enterprise/features/flow-hitl-management.mdx

@@ -38,21 +38,22 @@ CrewAI Enterprise provides a comprehensive Human-in-the-Loop (HITL) management s
 Configure human review checkpoints within your Flows using the `@human_feedback` decorator. When execution reaches a review point, the system pauses, notifies the assignee via email, and waits for a response.
 
 ```python
-from crewai.flow.flow import Flow, start, listen, or_
+from crewai.flow.flow import Flow, start, listen
 from crewai.flow.human_feedback import human_feedback, HumanFeedbackResult
 
 class ContentApprovalFlow(Flow):
     @start()
     def generate_content(self):
+        # AI generates content
         return "Generated marketing copy for Q1 campaign..."
 
+    @listen(generate_content)
     @human_feedback(
         message="Please review this content for brand compliance:",
         emit=["approved", "rejected", "needs_revision"],
     )
-    @listen(or_("generate_content", "needs_revision"))
-    def review_content(self):
-        return "Marketing copy for review..."
+    def review_content(self, content):
+        return content
 
     @listen("approved")
     def publish_content(self, result: HumanFeedbackResult):
@@ -61,6 +62,10 @@ class ContentApprovalFlow(Flow):
     @listen("rejected")
     def archive_content(self, result: HumanFeedbackResult):
         print(f"Content rejected. Reason: {result.feedback}")
+
+    @listen("needs_revision")
+    def revise_content(self, result: HumanFeedbackResult):
+        print(f"Revision requested: {result.feedback}")
 ```
 
 For complete implementation details, see the [Human Feedback in Flows](/en/learn/human-feedback-in-flows) guide.

docs/en/enterprise/guides/deploy-to-amp.mdx

@@ -177,11 +177,6 @@ You need to push your crew to a GitHub repository. If you haven't created a crew
       ![Set Environment Variables](/images/enterprise/set-env-variables.png)
     </Frame>
 
-    <Info>
-      Using private Python packages? You'll need to add your registry credentials here too.
-      See [Private Package Registries](/en/enterprise/guides/private-package-registry) for the required variables.
-    </Info>
-
   </Step>
 
   <Step title="Deploy Your Crew">

docs/en/enterprise/guides/prepare-for-deployment.mdx

@@ -256,12 +256,6 @@ Before deployment, ensure you have:
 1. **LLM API keys** ready (OpenAI, Anthropic, Google, etc.)
 2. **Tool API keys** if using external tools (Serper, etc.)
 
-<Info>
-  If your project depends on packages from a **private PyPI registry**, you'll also need to configure
-  registry authentication credentials as environment variables. See the
-  [Private Package Registries](/en/enterprise/guides/private-package-registry) guide for details.
-</Info>
-
 <Tip>
   Test your project locally with the same environment variables before deploying
   to catch configuration issues early.

docs/en/enterprise/guides/private-package-registry.mdx

@@ -1,263 +0,0 @@
----
-title: "Private Package Registries"
-description: "Install private Python packages from authenticated PyPI registries in CrewAI AMP"
-icon: "lock"
-mode: "wide"
----
-
-<Note>
-  This guide covers how to configure your CrewAI project to install Python packages
-  from private PyPI registries (Azure DevOps Artifacts, GitHub Packages, GitLab, AWS CodeArtifact, etc.)
-  when deploying to CrewAI AMP.
-</Note>
-
-## When You Need This
-
-If your project depends on internal or proprietary Python packages hosted on a private registry
-rather than the public PyPI, you'll need to:
-
-1. Tell UV **where** to find the package (an index URL)
-2. Tell UV **which** packages come from that index (a source mapping)
-3. Provide **credentials** so UV can authenticate during install
-
-CrewAI AMP uses [UV](https://docs.astral.sh/uv/) for dependency resolution and installation.
-UV supports authenticated private registries through `pyproject.toml` configuration combined
-with environment variables for credentials.
-
-## Step 1: Configure pyproject.toml
-
-Three pieces work together in your `pyproject.toml`:
-
-### 1a. Declare the dependency
-
-Add the private package to your `[project.dependencies]` like any other dependency:
-
-```toml
-[project]
-dependencies = [
-    "crewai[tools]>=0.100.1,<1.0.0",
-    "my-private-package>=1.2.0",
-]
-```
-
-### 1b. Define the index
-
-Register your private registry as a named index under `[[tool.uv.index]]`:
-
-```toml
-[[tool.uv.index]]
-name = "my-private-registry"
-url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
-explicit = true
-```
-
-<Info>
-  The `name` field is important — UV uses it to construct the environment variable names
-  for authentication (see [Step 2](#step-2-set-authentication-credentials) below).
-
-  Setting `explicit = true` means UV won't search this index for every package — only the
-  ones you explicitly map to it in `[tool.uv.sources]`. This avoids unnecessary queries
-  against your private registry and protects against dependency confusion attacks.
-</Info>
-
-### 1c. Map the package to the index
-
-Tell UV which packages should be resolved from your private index using `[tool.uv.sources]`:
-
-```toml
-[tool.uv.sources]
-my-private-package = { index = "my-private-registry" }
-```
-
-### Complete example
-
-```toml
-[project]
-name = "my-crew-project"
-version = "0.1.0"
-requires-python = ">=3.10,<=3.13"
-dependencies = [
-    "crewai[tools]>=0.100.1,<1.0.0",
-    "my-private-package>=1.2.0",
-]
-
-[tool.crewai]
-type = "crew"
-
-[[tool.uv.index]]
-name = "my-private-registry"
-url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
-explicit = true
-
-[tool.uv.sources]
-my-private-package = { index = "my-private-registry" }
-```
-
-After updating `pyproject.toml`, regenerate your lock file:
-
-```bash
-uv lock
-```
-
-<Warning>
-  Always commit the updated `uv.lock` along with your `pyproject.toml` changes.
-  The lock file is required for deployment — see [Prepare for Deployment](/en/enterprise/guides/prepare-for-deployment).
-</Warning>
-
-## Step 2: Set Authentication Credentials
-
-UV authenticates against private indexes using environment variables that follow a naming convention
-based on the index name you defined in `pyproject.toml`:
-
-```
-UV_INDEX_{UPPER_NAME}_USERNAME
-UV_INDEX_{UPPER_NAME}_PASSWORD
-```
-
-Where `{UPPER_NAME}` is your index name converted to **uppercase** with **hyphens replaced by underscores**.
-
-For example, an index named `my-private-registry` uses:
-
-| Variable | Value |
-|----------|-------|
-| `UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME` | Your registry username or token name |
-| `UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD` | Your registry password or token/PAT |
-
-<Warning>
-  These environment variables **must** be added via the CrewAI AMP **Environment Variables** settings —
-  either globally or at the deployment level. They cannot be set in `.env` files or hardcoded in your project.
-
-  See [Setting Environment Variables in AMP](#setting-environment-variables-in-amp) below.
-</Warning>
-
-## Registry Provider Reference
-
-The table below shows the index URL format and credential values for common registry providers.
-Replace placeholder values with your actual organization and feed details.
-
-| Provider | Index URL | Username | Password |
-|----------|-----------|----------|----------|
-| **Azure DevOps Artifacts** | `https://pkgs.dev.azure.com/{org}/_packaging/{feed}/pypi/simple/` | Any non-empty string (e.g. `token`) | Personal Access Token (PAT) with Packaging Read scope |
-| **GitHub Packages** | `https://pypi.pkg.github.com/{owner}/simple/` | GitHub username | Personal Access Token (classic) with `read:packages` scope |
-| **GitLab Package Registry** | `https://gitlab.com/api/v4/projects/{project_id}/packages/pypi/simple/` | `__token__` | Project or Personal Access Token with `read_api` scope |
-| **AWS CodeArtifact** | Use the URL from `aws codeartifact get-repository-endpoint` | `aws` | Token from `aws codeartifact get-authorization-token` |
-| **Google Artifact Registry** | `https://{region}-python.pkg.dev/{project}/{repo}/simple/` | `_json_key_base64` | Base64-encoded service account key |
-| **JFrog Artifactory** | `https://{instance}.jfrog.io/artifactory/api/pypi/{repo}/simple/` | Username or email | API key or identity token |
-| **Self-hosted (devpi, Nexus, etc.)** | Your registry's simple API URL | Registry username | Registry password |
-
-<Tip>
-  For **AWS CodeArtifact**, the authorization token expires periodically.
-  You'll need to refresh the `UV_INDEX_*_PASSWORD` value when it expires.
-  Consider automating this in your CI/CD pipeline.
-</Tip>
-
-## Setting Environment Variables in AMP
-
-Private registry credentials must be configured as environment variables in CrewAI AMP.
-You have two options:
-
-<Tabs>
-  <Tab title="Web Interface">
-    1. Log in to [CrewAI AMP](https://app.crewai.com)
-    2. Navigate to your automation
-    3. Open the **Environment Variables** tab
-    4. Add each variable (`UV_INDEX_*_USERNAME` and `UV_INDEX_*_PASSWORD`) with its value
-
-    See the [Deploy to AMP — Set Environment Variables](/en/enterprise/guides/deploy-to-amp#set-environment-variables) step for details.
-  </Tab>
-  <Tab title="CLI Deployment">
-    Add the variables to your local `.env` file before running `crewai deploy create`.
-    The CLI will securely transfer them to the platform:
-
-    ```bash
-    # .env
-    OPENAI_API_KEY=sk-...
-    UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
-    UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat-here
-    ```
-
-    ```bash
-    crewai deploy create
-    ```
-  </Tab>
-</Tabs>
-
-<Warning>
-  **Never** commit credentials to your repository. Use AMP environment variables for all secrets.
-  The `.env` file should be listed in `.gitignore`.
-</Warning>
-
-To update credentials on an existing deployment, see [Update Your Crew — Environment Variables](/en/enterprise/guides/update-crew).
-
-## How It All Fits Together
-
-When CrewAI AMP builds your automation, the resolution flow works like this:
-
-<Steps>
-  <Step title="Build starts">
-    AMP pulls your repository and reads `pyproject.toml` and `uv.lock`.
-  </Step>
-  <Step title="UV resolves dependencies">
-    UV reads `[tool.uv.sources]` to determine which index each package should come from.
-  </Step>
-  <Step title="UV authenticates">
-    For each private index, UV looks up `UV_INDEX_{NAME}_USERNAME` and `UV_INDEX_{NAME}_PASSWORD`
-    from the environment variables you configured in AMP.
-  </Step>
-  <Step title="Packages install">
-    UV downloads and installs all packages — both public (from PyPI) and private (from your registry).
-  </Step>
-  <Step title="Automation runs">
-    Your crew or flow starts with all dependencies available.
-  </Step>
-</Steps>
-
-## Troubleshooting
-
-### Authentication Errors During Build
-
-**Symptom**: Build fails with `401 Unauthorized` or `403 Forbidden` when resolving a private package.
-
-**Check**:
-- The `UV_INDEX_*` environment variable names match your index name exactly (uppercased, hyphens → underscores)
-- Credentials are set in AMP environment variables, not just in a local `.env`
-- Your token/PAT has the required read permissions for the package feed
-- The token hasn't expired (especially relevant for AWS CodeArtifact)
-
-### Package Not Found
-
-**Symptom**: `No matching distribution found for my-private-package`.
-
-**Check**:
-- The index URL in `pyproject.toml` ends with `/simple/`
-- The `[tool.uv.sources]` entry maps the correct package name to the correct index name
-- The package is actually published to your private registry
-- Run `uv lock` locally with the same credentials to verify resolution works
-
-### Lock File Conflicts
-
-**Symptom**: `uv lock` fails or produces unexpected results after adding a private index.
-
-**Solution**: Set the credentials locally and regenerate:
-
-```bash
-export UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
-export UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat
-uv lock
-```
-
-Then commit the updated `uv.lock`.
-
-## Related Guides
-
-<CardGroup cols={3}>
-  <Card title="Prepare for Deployment" icon="clipboard-check" href="/en/enterprise/guides/prepare-for-deployment">
-    Verify project structure and dependencies before deploying.
-  </Card>
-  <Card title="Deploy to AMP" icon="rocket" href="/en/enterprise/guides/deploy-to-amp">
-    Deploy your crew or flow and configure environment variables.
-  </Card>
-  <Card title="Update Your Crew" icon="arrows-rotate" href="/en/enterprise/guides/update-crew">
-    Update environment variables and push changes to a running deployment.
-  </Card>
-</CardGroup>

docs/en/learn/human-feedback-in-flows.mdx

@@ -73,8 +73,6 @@ When this flow runs, it will:
 | `default_outcome` | `str` | No | Outcome to use if no feedback provided. Must be in `emit` |
 | `metadata` | `dict` | No | Additional data for enterprise integrations |
 | `provider` | `HumanFeedbackProvider` | No | Custom provider for async/non-blocking feedback. See [Async Human Feedback](#async-human-feedback-non-blocking) |
-| `learn` | `bool` | No | Enable HITL learning: distill lessons from feedback and pre-review future output. Default `False`. See [Learning from Feedback](#learning-from-feedback) |
-| `learn_limit` | `int` | No | Max past lessons to recall for pre-review. Default `5` |
 
 ### Basic Usage (No Routing)
 
@@ -98,43 +96,33 @@ def handle_feedback(self, result):
 When you specify `emit`, the decorator becomes a router. The human's free-form feedback is interpreted by an LLM and collapsed into one of the specified outcomes:
 
 ```python Code
-from crewai.flow.flow import Flow, start, listen, or_
-from crewai.flow.human_feedback import human_feedback
+@start()
+@human_feedback(
+    message="Do you approve this content for publication?",
+    emit=["approved", "rejected", "needs_revision"],
+    llm="gpt-4o-mini",
+    default_outcome="needs_revision",
+)
+def review_content(self):
+    return "Draft blog post content here..."
 
-class ReviewFlow(Flow):
-    @start()
-    def generate_content(self):
-        return "Draft blog post content here..."
+@listen("approved")
+def publish(self, result):
+    print(f"Publishing! User said: {result.feedback}")
 
-    @human_feedback(
-        message="Do you approve this content for publication?",
-        emit=["approved", "rejected", "needs_revision"],
-        llm="gpt-4o-mini",
-        default_outcome="needs_revision",
-    )
-    @listen(or_("generate_content", "needs_revision"))
-    def review_content(self):
-        return "Draft blog post content here..."
+@listen("rejected")
+def discard(self, result):
+    print(f"Discarding. Reason: {result.feedback}")
 
-    @listen("approved")
-    def publish(self, result):
-        print(f"Publishing! User said: {result.feedback}")
-
-    @listen("rejected")
-    def discard(self, result):
-        print(f"Discarding. Reason: {result.feedback}")
+@listen("needs_revision")
+def revise(self, result):
+    print(f"Revising based on: {result.feedback}")
 ```
 
-When the human says something like "needs more detail", the LLM collapses that to `"needs_revision"`, which triggers `review_content` again via `or_()` — creating a revision loop. The loop continues until the outcome is `"approved"` or `"rejected"`.
-
 <Tip>
 The LLM uses structured outputs (function calling) when available to guarantee the response is one of your specified outcomes. This makes routing reliable and predictable.
 </Tip>
 
-<Warning>
-A `@start()` method only runs once at the beginning of the flow. If you need a revision loop, separate the start method from the review method and use `@listen(or_("trigger", "revision_outcome"))` on the review method to enable the self-loop.
-</Warning>
-
 ## HumanFeedbackResult
 
 The `HumanFeedbackResult` dataclass contains all information about a human feedback interaction:
@@ -198,183 +186,127 @@ Each `HumanFeedbackResult` is appended to `human_feedback_history`, so multiple
 
 ## Complete Example: Content Approval Workflow
 
-Here's a full example implementing a content review and approval workflow with a revision loop:
+Here's a full example implementing a content review and approval workflow:
 
 <CodeGroup>
 
 ```python Code
-from crewai.flow.flow import Flow, start, listen, or_
+from crewai.flow.flow import Flow, start, listen
 from crewai.flow.human_feedback import human_feedback, HumanFeedbackResult
 from pydantic import BaseModel
 
 
 class ContentState(BaseModel):
+    topic: str = ""
     draft: str = ""
+    final_content: str = ""
     revision_count: int = 0
-    status: str = "pending"
 
 
 class ContentApprovalFlow(Flow[ContentState]):
-    """A flow that generates content and loops until the human approves."""
+    """A flow that generates content and gets human approval."""
 
     @start()
-    def generate_draft(self):
-        self.state.draft = "# AI Safety\n\nThis is a draft about AI Safety..."
+    def get_topic(self):
+        self.state.topic = input("What topic should I write about? ")
+        return self.state.topic
+
+    @listen(get_topic)
+    def generate_draft(self, topic):
+        # In real use, this would call an LLM
+        self.state.draft = f"# {topic}\n\nThis is a draft about {topic}..."
         return self.state.draft
 
+    @listen(generate_draft)
     @human_feedback(
-        message="Please review this draft. Approve, reject, or describe what needs changing:",
+        message="Please review this draft. Reply 'approved', 'rejected', or provide revision feedback:",
         emit=["approved", "rejected", "needs_revision"],
         llm="gpt-4o-mini",
         default_outcome="needs_revision",
     )
-    @listen(or_("generate_draft", "needs_revision"))
-    def review_draft(self):
-        self.state.revision_count += 1
-        return f"{self.state.draft} (v{self.state.revision_count})"
+    def review_draft(self, draft):
+        return draft
 
     @listen("approved")
     def publish_content(self, result: HumanFeedbackResult):
-        self.state.status = "published"
-        print(f"Content approved and published! Reviewer said: {result.feedback}")
+        self.state.final_content = result.output
+        print("\n✅ Content approved and published!")
+        print(f"Reviewer comment: {result.feedback}")
         return "published"
 
     @listen("rejected")
     def handle_rejection(self, result: HumanFeedbackResult):
-        self.state.status = "rejected"
-        print(f"Content rejected. Reason: {result.feedback}")
+        print("\n❌ Content rejected")
+        print(f"Reason: {result.feedback}")
         return "rejected"
 
+    @listen("needs_revision")
+    def revise_content(self, result: HumanFeedbackResult):
+        self.state.revision_count += 1
+        print(f"\n📝 Revision #{self.state.revision_count} requested")
+        print(f"Feedback: {result.feedback}")
 
+        # In a real flow, you might loop back to generate_draft
+        # For this example, we just acknowledge
+        return "revision_requested"
+
+
+# Run the flow
 flow = ContentApprovalFlow()
 result = flow.kickoff()
-print(f"\nFlow completed. Status: {flow.state.status}, Reviews: {flow.state.revision_count}")
+print(f"\nFlow completed. Revisions requested: {flow.state.revision_count}")
 ```
 
 ```text Output
-==================================================
-OUTPUT FOR REVIEW:
-==================================================
-# AI Safety
-
-This is a draft about AI Safety... (v1)
-==================================================
-
-Please review this draft. Approve, reject, or describe what needs changing:
-(Press Enter to skip, or type your feedback)
-
-Your feedback: Needs more detail on alignment research
+What topic should I write about? AI Safety
 
 ==================================================
 OUTPUT FOR REVIEW:
 ==================================================
 # AI Safety
 
-This is a draft about AI Safety... (v2)
+This is a draft about AI Safety...
 ==================================================
 
-Please review this draft. Approve, reject, or describe what needs changing:
+Please review this draft. Reply 'approved', 'rejected', or provide revision feedback:
 (Press Enter to skip, or type your feedback)
 
 Your feedback: Looks good, approved!
 
-Content approved and published! Reviewer said: Looks good, approved!
+✅ Content approved and published!
+Reviewer comment: Looks good, approved!
 
-Flow completed. Status: published, Reviews: 2
+Flow completed. Revisions requested: 0
 ```
 
 </CodeGroup>
 
-The key pattern is `@listen(or_("generate_draft", "needs_revision"))` — the review method listens to both the initial trigger and its own revision outcome, creating a self-loop that repeats until the human approves or rejects.
-
 ## Combining with Other Decorators
 
-The `@human_feedback` decorator works with `@start()`, `@listen()`, and `or_()`. Both decorator orderings work — the framework propagates attributes in both directions — but the recommended patterns are:
+The `@human_feedback` decorator works with other flow decorators. Place it as the innermost decorator (closest to the function):
 
 ```python Code
-# One-shot review at the start of a flow (no self-loop)
+# Correct: @human_feedback is innermost (closest to the function)
 @start()
-@human_feedback(message="Review this:", emit=["approved", "rejected"], llm="gpt-4o-mini")
+@human_feedback(message="Review this:")
 def my_start_method(self):
     return "content"
 
-# Linear review on a listener (no self-loop)
 @listen(other_method)
-@human_feedback(message="Review this too:", emit=["good", "bad"], llm="gpt-4o-mini")
+@human_feedback(message="Review this too:")
 def my_listener(self, data):
     return f"processed: {data}"
-
-# Self-loop: review that can loop back for revisions
-@human_feedback(message="Approve or revise?", emit=["approved", "revise"], llm="gpt-4o-mini")
-@listen(or_("upstream_method", "revise"))
-def review_with_loop(self):
-    return "content for review"
 ```
 
-### Self-loop pattern
-
-To create a revision loop, the review method must listen to **both** an upstream trigger and its own revision outcome using `or_()`:
-
-```python Code
-@start()
-def generate(self):
-    return "initial draft"
-
-@human_feedback(
-    message="Approve or request changes?",
-    emit=["revise", "approved"],
-    llm="gpt-4o-mini",
-    default_outcome="approved",
-)
-@listen(or_("generate", "revise"))
-def review(self):
-    return "content"
-
-@listen("approved")
-def publish(self):
-    return "published"
-```
-
-When the outcome is `"revise"`, the flow routes back to `review` (because it listens to `"revise"` via `or_()`). When the outcome is `"approved"`, the flow continues to `publish`. This works because the flow engine exempts routers from the "fire once" rule, allowing them to re-execute on each loop iteration.
-
-### Chained routers
-
-A listener triggered by one router's outcome can itself be a router:
-
-```python Code
-@start()
-def generate(self):
-    return "draft content"
-
-@human_feedback(message="First review:", emit=["approved", "rejected"], llm="gpt-4o-mini")
-@listen("generate")
-def first_review(self):
-    return "draft content"
-
-@human_feedback(message="Final review:", emit=["publish", "hold"], llm="gpt-4o-mini")
-@listen("approved")
-def final_review(self, prev):
-    return "final content"
-
-@listen("publish")
-def on_publish(self, prev):
-    return "published"
-
-@listen("hold")
-def on_hold(self, prev):
-    return "held for later"
-```
-
-### Limitations
-
-- **`@start()` methods run once**: A `@start()` method cannot self-loop. If you need a revision cycle, use a separate `@start()` method as the entry point and put the `@human_feedback` on a `@listen()` method.
-- **No `@start()` + `@listen()` on the same method**: This is a Flow framework constraint. A method is either a start point or a listener, not both.
+<Tip>
+Place `@human_feedback` as the innermost decorator (last/closest to the function) so it wraps the method directly and can capture the return value before passing to the flow system.
+</Tip>
 
 ## Best Practices
 
 ### 1. Write Clear Request Messages
 
-The `message` parameter is what the human sees. Make it actionable:
+The `request` parameter is what the human sees. Make it actionable:
 
 ```python Code
 # ✅ Good - clear and actionable
@@ -582,9 +514,9 @@ class ContentPipeline(Flow):
     @start()
     @human_feedback(
         message="Approve this content for publication?",
-        emit=["approved", "rejected"],
+        emit=["approved", "rejected", "needs_revision"],
         llm="gpt-4o-mini",
-        default_outcome="rejected",
+        default_outcome="needs_revision",
         provider=SlackNotificationProvider("#content-reviews"),
     )
     def generate_content(self):
@@ -600,6 +532,11 @@ class ContentPipeline(Flow):
         print(f"Archived. Reason: {result.feedback}")
         return {"status": "archived"}
 
+    @listen("needs_revision")
+    def queue_revision(self, result):
+        print(f"Queued for revision: {result.feedback}")
+        return {"status": "revision_needed"}
+
 
 # Starting the flow (will pause and wait for Slack response)
 def start_content_pipeline():
@@ -639,64 +576,6 @@ If you're using an async web framework (FastAPI, aiohttp, Slack Bolt async mode)
 5. **Automatic persistence**: State is automatically saved when `HumanFeedbackPending` is raised and uses `SQLiteFlowPersistence` by default
 6. **Custom persistence**: Pass a custom persistence instance to `from_pending()` if needed
 
-## Learning from Feedback
-
-The `learn=True` parameter enables a feedback loop between human reviewers and the memory system. When enabled, the system progressively improves its outputs by learning from past human corrections.
-
-### How It Works
-
-1. **After feedback**: The LLM extracts generalizable lessons from the output + feedback and stores them in memory with `source="hitl"`. If the feedback is just approval (e.g. "looks good"), nothing is stored.
-2. **Before next review**: Past HITL lessons are recalled from memory and applied by the LLM to improve the output before the human sees it.
-
-Over time, the human sees progressively better pre-reviewed output because each correction informs future reviews.
-
-### Example
-
-```python Code
-class ArticleReviewFlow(Flow):
-    @start()
-    def generate_article(self):
-        return self.crew.kickoff(inputs={"topic": "AI Safety"}).raw
-
-    @human_feedback(
-        message="Review this article draft:",
-        emit=["approved", "needs_revision"],
-        llm="gpt-4o-mini",
-        learn=True,  # enable HITL learning
-    )
-    @listen(or_("generate_article", "needs_revision"))
-    def review_article(self):
-        return self.last_human_feedback.output if self.last_human_feedback else "article draft"
-
-    @listen("approved")
-    def publish(self):
-        print(f"Publishing: {self.last_human_feedback.output}")
-```
-
-**First run**: The human sees the raw output and says "Always include citations for factual claims." The lesson is distilled and stored in memory.
-
-**Second run**: The system recalls the citation lesson, pre-reviews the output to add citations, then shows the improved version. The human's job shifts from "fix everything" to "catch what the system missed."
-
-### Configuration
-
-| Parameter | Default | Description |
-|-----------|---------|-------------|
-| `learn` | `False` | Enable HITL learning |
-| `learn_limit` | `5` | Max past lessons to recall for pre-review |
-
-### Key Design Decisions
-
-- **Same LLM for everything**: The `llm` parameter on the decorator is shared by outcome collapsing, lesson distillation, and pre-review. No need to configure multiple models.
-- **Structured output**: Both distillation and pre-review use function calling with Pydantic models when the LLM supports it, falling back to text parsing otherwise.
-- **Non-blocking storage**: Lessons are stored via `remember_many()` which runs in a background thread -- the flow continues immediately.
-- **Graceful degradation**: If the LLM fails during distillation, nothing is stored. If it fails during pre-review, the raw output is shown. Neither failure blocks the flow.
-- **No scope/categories needed**: When storing lessons, only `source` is passed. The encoding pipeline infers scope, categories, and importance automatically.
-
-<Note>
-`learn=True` requires the Flow to have memory available. Flows get memory automatically by default, but if you've disabled it with `_skip_auto_memory`, HITL learning will be silently skipped.
-</Note>
-
-
 ## Related Documentation
 
 - [Flows Overview](/en/concepts/flows) - Learn about CrewAI Flows
@@ -704,4 +583,3 @@ class ArticleReviewFlow(Flow):
 - [Flow Persistence](/en/concepts/flows#persistence) - Persisting flow state
 - [Routing with @router](/en/concepts/flows#router) - More about conditional routing
 - [Human Input on Execution](/en/learn/human-input-on-execution) - Task-level human input
-- [Memory](/en/concepts/memory) - The unified memory system used by HITL learning

docs/en/learn/llm-connections.mdx

@@ -7,7 +7,7 @@ mode: "wide"
 
 ## Connect CrewAI to LLMs
 
-CrewAI connects to LLMs through native SDK integrations for the most popular providers (OpenAI, Anthropic, Google Gemini, Azure, and AWS Bedrock), and uses LiteLLM as a flexible fallback for all other providers.
+CrewAI uses LiteLLM to connect to a wide variety of Language Models (LLMs). This integration provides extensive versatility, allowing you to use models from numerous providers with a simple, unified interface.
 
 <Note>
     By default, CrewAI uses the `gpt-4o-mini` model. This is determined by the `OPENAI_MODEL_NAME` environment variable, which defaults to "gpt-4o-mini" if not set.
@@ -41,14 +41,6 @@ LiteLLM supports a wide range of providers, including but not limited to:
 
 For a complete and up-to-date list of supported providers, please refer to the [LiteLLM Providers documentation](https://docs.litellm.ai/docs/providers).
 
-<Info>
-  To use any provider not covered by a native integration, add LiteLLM as a dependency to your project:
-  ```bash
-  uv add 'crewai[litellm]'
-  ```
-  Native providers (OpenAI, Anthropic, Google Gemini, Azure, AWS Bedrock) use their own SDK extras — see the [Provider Configuration Examples](/en/concepts/llms#provider-configuration-examples).
-</Info>
-
 ## Changing the LLM
 
 To use a different LLM with your CrewAI agents, you have several options:

docs/en/observability/tracing.mdx

@@ -35,7 +35,7 @@ Visit [app.crewai.com](https://app.crewai.com) and create your free account. Thi
 If you haven't already, install CrewAI with the CLI tools:
 
 ```bash
-uv add 'crewai[tools]'
+uv add crewai[tools]
 ```
 
 Then authenticate your CLI with your CrewAI AMP account:

docs/en/tools/automation/composiotool.mdx

@@ -18,46 +18,77 @@ Composio is an integration platform that allows you to connect your AI agents to
 To incorporate Composio tools into your project, follow the instructions below:
 
 ```shell
-pip install composio composio-crewai
+pip install composio-crewai
 pip install crewai
 ```
 
-After the installation is complete, set your Composio API key as `COMPOSIO_API_KEY`. Get your Composio API key from [here](https://platform.composio.dev)
+After the installation is complete, either run `composio login` or export your composio API key as `COMPOSIO_API_KEY`. Get your Composio API key from [here](https://app.composio.dev)
 
 ## Example
 
 The following example demonstrates how to initialize the tool and execute a github action:
 
-1. Initialize Composio with CrewAI Provider
+1. Initialize Composio toolset
 
 ```python Code
-from composio_crewai import ComposioProvider
-from composio import Composio
+from composio_crewai import ComposioToolSet, App, Action
 from crewai import Agent, Task, Crew
 
-composio = Composio(provider=ComposioProvider())
+toolset = ComposioToolSet()
 ```
 
-2. Create a new Composio Session and retrieve the tools
+2. Connect your GitHub account
 <CodeGroup>
-```python
-session = composio.create(
-    user_id="your-user-id",
-    toolkits=["gmail", "github"] # optional, default is all toolkits
-)
-tools = session.tools()
+```shell CLI
+composio add github
+```
+```python Code
+request = toolset.initiate_connection(app=App.GITHUB)
+print(f"Open this URL to authenticate: {request.redirectUrl}")
 ```
-Read more about sessions and user management [here](https://docs.composio.dev/docs/configuring-sessions)
 </CodeGroup>
 
-3. Authenticating users manually
+3. Get Tools
 
-Composio automatically authenticates the users during the agent chat session. However, you can also authenticate the user manually by calling the `authorize` method.
+- Retrieving all the tools from an app (not recommended for production):
 ```python Code
-connection_request = session.authorize("github")
-print(f"Open this URL to authenticate: {connection_request.redirect_url}")
+tools = toolset.get_tools(apps=[App.GITHUB])
 ```
 
+- Filtering tools based on tags:
+```python Code
+tag = "users"
+
+filtered_action_enums = toolset.find_actions_by_tags(
+    App.GITHUB,
+    tags=[tag], 
+)
+
+tools = toolset.get_tools(actions=filtered_action_enums)
+```
+
+- Filtering tools based on use case:
+```python Code
+use_case = "Star a repository on GitHub"
+
+filtered_action_enums = toolset.find_actions_by_use_case(
+    App.GITHUB, use_case=use_case, advanced=False
+)
+
+tools = toolset.get_tools(actions=filtered_action_enums)
+```
+<Tip>Set `advanced` to True to get actions for complex use cases</Tip>
+
+- Using specific tools:
+
+In this demo, we will use the `GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER` action from the GitHub app.
+```python Code
+tools = toolset.get_tools(
+    actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER]
+)
+```
+Learn more about filtering actions [here](https://docs.composio.dev/patterns/tools/use-tools/use-specific-actions)
+
 4. Define agent
 
 ```python Code
@@ -85,4 +116,4 @@ crew = Crew(agents=[crewai_agent], tasks=[task])
 crew.kickoff()
 ```
 
-* More detailed list of tools can be found [here](https://docs.composio.dev/toolkits)
+* More detailed list of tools can be found [here](https://app.composio.dev)

docs/ko/changelog.mdx

@@ -4,106 +4,6 @@ description: "CrewAI의 제품 업데이트, 개선 사항 및 버그 수정"
 icon: "clock"
 mode: "wide"
 ---
-<Update label="2026년 2월 27일">
-  ## v1.10.1a1
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## 변경 사항
-
-  ### 기능
-  - 단계 콜백 메서드에서 비동기 호출 지원 구현
-  - 메모리 모듈의 무거운 의존성에 대한 지연 로딩 구현
-
-  ### 문서
-  - v1.10.0에 대한 변경 로그 및 버전 업데이트
-
-  ### 리팩토링
-  - 비동기 호출을 지원하기 위해 단계 콜백 메서드 리팩토링
-  - 메모리 모듈의 무거운 의존성에 대한 지연 로딩을 구현하기 위해 리팩토링
-
-  ### 버그 수정
-  - 릴리스 노트의 분기 수정
-
-  ## 기여자
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
-<Update label="2026년 2월 27일">
-  ## v1.10.1a1
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## 변경 사항
-
-  ### 리팩토링
-  - 비동기 호출을 지원하기 위해 단계 콜백 메서드 리팩토링
-  - 메모리 모듈의 무거운 의존성에 대해 지연 로딩 구현
-
-  ### 문서화
-  - v1.10.0에 대한 변경 로그 및 버전 업데이트
-
-  ### 버그 수정
-  - 릴리스 노트를 위한 브랜치 생성
-
-  ## 기여자
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
-<Update label="2026년 2월 26일">
-  ## v1.10.0
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.10.0)
-
-  ## 변경 사항
-
-  ### 기능
-  - MCP 도구 해상도 및 관련 이벤트 개선
-  - lancedb 버전 업데이트 및 lance-namespace 패키지 추가
-  - CrewAgentExecutor 및 BaseTool에서 JSON 인수 파싱 및 검증 개선
-  - CLI HTTP 클라이언트를 requests에서 httpx로 마이그레이션
-  - 버전화된 문서 추가
-  - 버전 노트에 대한 yanked 감지 추가
-  - Flows에서 사용자 입력 처리 구현
-  - 인간 피드백 통합 테스트에서 HITL 자기 루프 기능 개선
-  - eventbus에 started_event_id 추가 및 설정
-  - tools.specs 자동 업데이트
-
-  ### 버그 수정
-  - 빈 경우에도 도구 kwargs를 검증하여 모호한 TypeError 방지
-  - LLM을 위한 도구 매개변수 스키마에서 null 타입 유지
-  - output_pydantic/output_json을 네이티브 구조화된 출력으로 매핑
-  - 약속이 있는 경우 콜백이 실행/대기되도록 보장
-  - 예외 컨텍스트에서 메서드 이름 캡처
-  - 라우터 결과에서 enum 타입 유지; 타입 개선
-  - 입력으로 지속성 ID가 전달될 때 조용히 깨지는 순환 흐름 수정
-  - CLI 플래그 형식을 --skip-provider에서 --skip_provider로 수정
-  - OpenAI 도구 호출 스트림이 완료되도록 보장
-  - MCP 도구에서 복잡한 스키마 $ref 포인터 해결
-  - 스키마에서 additionalProperties=false 강제 적용
-  - 크루 폴더에 대해 예약된 스크립트 이름 거부
-  - 가드레일 이벤트 방출 테스트에서 경쟁 조건 해결
-
-  ### 문서
-  - 비네이티브 LLM 공급자를 위한 litellm 종속성 노트 추가
-  - NL2SQL 보안 모델 및 강화 지침 명확화
-  - 9개 통합에서 96개의 누락된 작업 추가
-
-  ### 리팩토링
-  - crew를 provider로 리팩토링
-  - HITL을 provider 패턴으로 추출
-  - 훅 타이핑 및 등록 개선
-
-  ## 기여자
-
-  @dependabot[bot], @github-actions[bot], @github-code-quality[bot], @greysonlalonde, @heitorado, @hobostay, @joaomdmoura, @johnvan7, @jonathansampson, @lorenzejay, @lucasgomide, @mattatcha, @mplachta, @nicoferdi96, @theCyberTech, @thiagomoretto, @vinibrsl
-
-</Update>
-
 <Update label="2026년 1월 26일">
   ## v1.9.0
 

docs/ko/concepts/llms.mdx

@@ -105,15 +105,6 @@ CrewAI 코드 내에는 사용할 모델을 지정할 수 있는 여러 위치
   </Tab>
 </Tabs>
 
-<Info>
-  CrewAI는 OpenAI, Anthropic, Google (Gemini API), Azure, AWS Bedrock에 대해 네이티브 SDK 통합을 제공합니다 — 제공자별 extras(예: `uv add "crewai[openai]"`) 외에 추가 설치가 필요하지 않습니다.
-
-  그 외 모든 제공자는 **LiteLLM**을 통해 지원됩니다. 이를 사용하려면 프로젝트에 의존성으로 추가하세요:
-  ```bash
-  uv add 'crewai[litellm]'
-  ```
-</Info>
-
 ## 공급자 구성 예시
 
 CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양한 LLM 공급자를 지원합니다.
@@ -223,11 +214,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
     | `meta_llama/Llama-4-Maverick-17B-128E-Instruct-FP8` | 128k | 4028 | 텍스트, 이미지     | 텍스트           |
     | `meta_llama/Llama-3.3-70B-Instruct`               | 128k | 4028       | 텍스트            | 텍스트           |
     | `meta_llama/Llama-3.3-8B-Instruct`                | 128k | 4028       | 텍스트            | 텍스트           |
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Anthropic">
@@ -368,11 +354,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
     | gemini-1.5-flash                 | 1M 토큰         | 밸런스 잡힌 멀티모달 모델, 대부분의 작업에 적합                         |
     | gemini-1.5-flash-8B              | 1M 토큰         | 가장 빠르고, 비용 효율적, 고빈도 작업에 적합                            |
     | gemini-1.5-pro                   | 2M 토큰         | 최고의 성능, 논리적 추론, 코딩, 창의적 협업 등 다양한 추론 작업에 적합   |
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Azure">
@@ -458,11 +439,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
         model="sagemaker/<my-endpoint>"
     )
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Mistral">
@@ -478,11 +454,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
         temperature=0.7
     )
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Nvidia NIM">
@@ -569,11 +540,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
     | rakuten/rakutenai-7b-instruct                                          | 1,024 토큰     | 언어 이해, 추론, 텍스트 생성이 탁월한 최첨단 LLM                         |
     | rakuten/rakutenai-7b-chat                                              | 1,024 토큰     | 언어 이해, 추론, 텍스트 생성이 탁월한 최첨단 LLM                         |
     | baichuan-inc/baichuan2-13b-chat                                        | 4,096 토큰     | 중국어 및 영어 대화, 코딩, 수학, 지시 따르기, 퀴즈 풀이 지원             |
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Local NVIDIA NIM Deployed using WSL2">
@@ -614,11 +580,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
 
         # ...
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Groq">
@@ -640,11 +601,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
     | Llama 3.1 70B/8B| 131,072 토큰      | 고성능, 대용량 문맥 작업         |
     | Llama 3.2 Series| 8,192 토큰        | 범용 작업                        |
     | Mixtral 8x7B    | 32,768 토큰       | 성능과 문맥의 균형               |
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="IBM watsonx.ai">
@@ -667,11 +623,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
         base_url="https://api.watsonx.ai/v1"
     )
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Ollama (Local LLMs)">
@@ -685,11 +636,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
         base_url="http://localhost:11434"
     )
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Fireworks AI">
@@ -705,11 +651,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
         temperature=0.7
     )
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Perplexity AI">
@@ -725,11 +666,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
         base_url="https://api.perplexity.ai/"
     )
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Hugging Face">
@@ -744,11 +680,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
         model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct"
     )
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="SambaNova">
@@ -772,11 +703,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
     | Llama 3.2 Series| 8,192 토큰         | 범용, 멀티모달 작업                  |
     | Llama 3.3 70B   | 최대 131,072 토큰   | 고성능, 높은 출력 품질               |
     | Qwen2 familly   | 8,192 토큰         | 고성능, 높은 출력 품질               |
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Cerebras">
@@ -802,11 +728,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
       - 속도와 품질의 우수한 밸런스
       - 긴 컨텍스트 윈도우 지원
     </Info>
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Open Router">
@@ -829,11 +750,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
       - openrouter/deepseek/deepseek-r1
       - openrouter/deepseek/deepseek-chat
     </Info>
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Nebius AI Studio">
@@ -856,11 +772,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
       - 경쟁력 있는 가격
       - 속도와 품질의 우수한 밸런스
     </Info>
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 </AccordionGroup>
 

docs/ko/enterprise/features/flow-hitl-management.mdx

@@ -38,21 +38,22 @@ CrewAI Enterprise는 AI 워크플로우를 협업적인 인간-AI 프로세스
 `@human_feedback` 데코레이터를 사용하여 Flow 내에 인간 검토 체크포인트를 구성합니다. 실행이 검토 포인트에 도달하면 시스템이 일시 중지되고, 담당자에게 이메일로 알리며, 응답을 기다립니다.
 
 ```python
-from crewai.flow.flow import Flow, start, listen, or_
+from crewai.flow.flow import Flow, start, listen
 from crewai.flow.human_feedback import human_feedback, HumanFeedbackResult
 
 class ContentApprovalFlow(Flow):
     @start()
     def generate_content(self):
+        # AI가 콘텐츠 생성
         return "Q1 캠페인용 마케팅 카피 생성..."
 
+    @listen(generate_content)
     @human_feedback(
         message="브랜드 준수를 위해 이 콘텐츠를 검토해 주세요:",
         emit=["approved", "rejected", "needs_revision"],
     )
-    @listen(or_("generate_content", "needs_revision"))
-    def review_content(self):
-        return "검토용 마케팅 카피..."
+    def review_content(self, content):
+        return content
 
     @listen("approved")
     def publish_content(self, result: HumanFeedbackResult):
@@ -61,6 +62,10 @@ class ContentApprovalFlow(Flow):
     @listen("rejected")
     def archive_content(self, result: HumanFeedbackResult):
         print(f"콘텐츠 거부됨. 사유: {result.feedback}")
+
+    @listen("needs_revision")
+    def revise_content(self, result: HumanFeedbackResult):
+        print(f"수정 요청: {result.feedback}")
 ```
 
 완전한 구현 세부 사항은 [Flow에서 인간 피드백](/ko/learn/human-feedback-in-flows) 가이드를 참조하세요.

docs/ko/enterprise/guides/deploy-to-amp.mdx

@@ -176,11 +176,6 @@ Crew를 GitHub 저장소에 푸시해야 합니다. 아직 Crew를 만들지 않
       ![Set Environment Variables](/images/enterprise/set-env-variables.png)
     </Frame>
 
-    <Info>
-      프라이빗 Python 패키지를 사용하시나요? 여기에 레지스트리 자격 증명도 추가해야 합니다.
-      필요한 변수는 [프라이빗 패키지 레지스트리](/ko/enterprise/guides/private-package-registry)를 참조하세요.
-    </Info>
-
   </Step>
 
   <Step title="Crew 배포하기">

docs/ko/enterprise/guides/prepare-for-deployment.mdx

@@ -256,12 +256,6 @@ Crews와 Flows 모두 `src/project_name/main.py`에 진입점이 있습니다:
 1. **LLM API 키** (OpenAI, Anthropic, Google 등)
 2. **도구 API 키** - 외부 도구를 사용하는 경우 (Serper 등)
 
-<Info>
-  프로젝트가 **프라이빗 PyPI 레지스트리**의 패키지에 의존하는 경우, 레지스트리 인증 자격 증명도
-  환경 변수로 구성해야 합니다. 자세한 내용은
-  [프라이빗 패키지 레지스트리](/ko/enterprise/guides/private-package-registry) 가이드를 참조하세요.
-</Info>
-
 <Tip>
   구성 문제를 조기에 발견하기 위해 배포 전에 동일한 환경 변수로
   로컬에서 프로젝트를 테스트하세요.

docs/ko/enterprise/guides/private-package-registry.mdx

@@ -1,261 +0,0 @@
----
-title: "프라이빗 패키지 레지스트리"
-description: "CrewAI AMP에서 인증된 PyPI 레지스트리의 프라이빗 Python 패키지 설치하기"
-icon: "lock"
-mode: "wide"
----
-
-<Note>
-  이 가이드는 CrewAI AMP에 배포할 때 프라이빗 PyPI 레지스트리(Azure DevOps Artifacts, GitHub Packages,
-  GitLab, AWS CodeArtifact 등)에서 Python 패키지를 설치하도록 CrewAI 프로젝트를 구성하는 방법을 다룹니다.
-</Note>
-
-## 이 가이드가 필요한 경우
-
-프로젝트가 공개 PyPI가 아닌 프라이빗 레지스트리에 호스팅된 내부 또는 독점 Python 패키지에
-의존하는 경우, 다음을 수행해야 합니다:
-
-1. UV에 패키지를 **어디서** 찾을지 알려줍니다 (index URL)
-2. UV에 **어떤** 패키지가 해당 index에서 오는지 알려줍니다 (source 매핑)
-3. UV가 설치 중에 인증할 수 있도록 **자격 증명**을 제공합니다
-
-CrewAI AMP는 의존성 해결 및 설치에 [UV](https://docs.astral.sh/uv/)를 사용합니다.
-UV는 `pyproject.toml` 구성과 자격 증명용 환경 변수를 결합하여 인증된 프라이빗 레지스트리를 지원합니다.
-
-## 1단계: pyproject.toml 구성
-
-`pyproject.toml`에서 세 가지 요소가 함께 작동합니다:
-
-### 1a. 의존성 선언
-
-프라이빗 패키지를 다른 의존성과 마찬가지로 `[project.dependencies]`에 추가합니다:
-
-```toml
-[project]
-dependencies = [
-    "crewai[tools]>=0.100.1,<1.0.0",
-    "my-private-package>=1.2.0",
-]
-```
-
-### 1b. index 정의
-
-프라이빗 레지스트리를 `[[tool.uv.index]]` 아래에 명명된 index로 등록합니다:
-
-```toml
-[[tool.uv.index]]
-name = "my-private-registry"
-url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
-explicit = true
-```
-
-<Info>
-  `name` 필드는 중요합니다 — UV는 이를 사용하여 인증을 위한 환경 변수 이름을
-  구성합니다 (아래 [2단계](#2단계-인증-자격-증명-설정)를 참조하세요).
-
-  `explicit = true`를 설정하면 UV가 모든 패키지에 대해 이 index를 검색하지 않습니다 —
-  `[tool.uv.sources]`에서 명시적으로 매핑한 패키지만 검색합니다. 이렇게 하면 프라이빗
-  레지스트리에 대한 불필요한 쿼리를 방지하고 의존성 혼동 공격을 차단할 수 있습니다.
-</Info>
-
-### 1c. 패키지를 index에 매핑
-
-`[tool.uv.sources]`를 사용하여 프라이빗 index에서 해결해야 할 패키지를 UV에 알려줍니다:
-
-```toml
-[tool.uv.sources]
-my-private-package = { index = "my-private-registry" }
-```
-
-### 전체 예시
-
-```toml
-[project]
-name = "my-crew-project"
-version = "0.1.0"
-requires-python = ">=3.10,<=3.13"
-dependencies = [
-    "crewai[tools]>=0.100.1,<1.0.0",
-    "my-private-package>=1.2.0",
-]
-
-[tool.crewai]
-type = "crew"
-
-[[tool.uv.index]]
-name = "my-private-registry"
-url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
-explicit = true
-
-[tool.uv.sources]
-my-private-package = { index = "my-private-registry" }
-```
-
-`pyproject.toml`을 업데이트한 후 lock 파일을 다시 생성합니다:
-
-```bash
-uv lock
-```
-
-<Warning>
-  업데이트된 `uv.lock`을 항상 `pyproject.toml` 변경 사항과 함께 커밋하세요.
-  lock 파일은 배포에 필수입니다 — [배포 준비하기](/ko/enterprise/guides/prepare-for-deployment)를 참조하세요.
-</Warning>
-
-## 2단계: 인증 자격 증명 설정
-
-UV는 `pyproject.toml`에서 정의한 index 이름을 기반으로 한 명명 규칙을 따르는
-환경 변수를 사용하여 프라이빗 index에 인증합니다:
-
-```
-UV_INDEX_{UPPER_NAME}_USERNAME
-UV_INDEX_{UPPER_NAME}_PASSWORD
-```
-
-여기서 `{UPPER_NAME}`은 index 이름을 **대문자**로 변환하고 **하이픈을 언더스코어로 대체**한 것입니다.
-
-예를 들어, `my-private-registry`라는 이름의 index는 다음을 사용합니다:
-
-| 변수 | 값 |
-|------|-----|
-| `UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME` | 레지스트리 사용자 이름 또는 토큰 이름 |
-| `UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD` | 레지스트리 비밀번호 또는 토큰/PAT |
-
-<Warning>
-  이 환경 변수는 CrewAI AMP **환경 변수** 설정을 통해 **반드시** 추가해야 합니다 —
-  전역적으로 또는 배포 수준에서. `.env` 파일에 설정하거나 프로젝트에 하드코딩할 수 없습니다.
-
-  아래 [AMP에서 환경 변수 설정](#amp에서-환경-변수-설정)을 참조하세요.
-</Warning>
-
-## 레지스트리 제공업체 참조
-
-아래 표는 일반적인 레지스트리 제공업체의 index URL 형식과 자격 증명 값을 보여줍니다.
-자리 표시자 값을 실제 조직 및 피드 세부 정보로 대체하세요.
-
-| 제공업체 | Index URL | 사용자 이름 | 비밀번호 |
-|---------|-----------|-----------|---------|
-| **Azure DevOps Artifacts** | `https://pkgs.dev.azure.com/{org}/_packaging/{feed}/pypi/simple/` | 비어 있지 않은 임의의 문자열 (예: `token`) | Packaging Read 범위의 Personal Access Token (PAT) |
-| **GitHub Packages** | `https://pypi.pkg.github.com/{owner}/simple/` | GitHub 사용자 이름 | `read:packages` 범위의 Personal Access Token (classic) |
-| **GitLab Package Registry** | `https://gitlab.com/api/v4/projects/{project_id}/packages/pypi/simple/` | `__token__` | `read_api` 범위의 Project 또는 Personal Access Token |
-| **AWS CodeArtifact** | `aws codeartifact get-repository-endpoint`의 URL 사용 | `aws` | `aws codeartifact get-authorization-token`의 토큰 |
-| **Google Artifact Registry** | `https://{region}-python.pkg.dev/{project}/{repo}/simple/` | `_json_key_base64` | Base64로 인코딩된 서비스 계정 키 |
-| **JFrog Artifactory** | `https://{instance}.jfrog.io/artifactory/api/pypi/{repo}/simple/` | 사용자 이름 또는 이메일 | API 키 또는 ID 토큰 |
-| **자체 호스팅 (devpi, Nexus 등)** | 레지스트리의 simple API URL | 레지스트리 사용자 이름 | 레지스트리 비밀번호 |
-
-<Tip>
-  **AWS CodeArtifact**의 경우 인증 토큰이 주기적으로 만료됩니다.
-  만료되면 `UV_INDEX_*_PASSWORD` 값을 갱신해야 합니다.
-  CI/CD 파이프라인에서 이를 자동화하는 것을 고려하세요.
-</Tip>
-
-## AMP에서 환경 변수 설정
-
-프라이빗 레지스트리 자격 증명은 CrewAI AMP에서 환경 변수로 구성해야 합니다.
-두 가지 옵션이 있습니다:
-
-<Tabs>
-  <Tab title="웹 인터페이스">
-    1. [CrewAI AMP](https://app.crewai.com)에 로그인합니다
-    2. 자동화로 이동합니다
-    3. **Environment Variables** 탭을 엽니다
-    4. 각 변수 (`UV_INDEX_*_USERNAME` 및 `UV_INDEX_*_PASSWORD`)에 값을 추가합니다
-
-    자세한 내용은 [AMP에 배포하기 — 환경 변수 설정하기](/ko/enterprise/guides/deploy-to-amp#환경-변수-설정하기) 단계를 참조하세요.
-  </Tab>
-  <Tab title="CLI 배포">
-    `crewai deploy create`를 실행하기 전에 로컬 `.env` 파일에 변수를 추가합니다.
-    CLI가 이를 안전하게 플랫폼으로 전송합니다:
-
-    ```bash
-    # .env
-    OPENAI_API_KEY=sk-...
-    UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
-    UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat-here
-    ```
-
-    ```bash
-    crewai deploy create
-    ```
-  </Tab>
-</Tabs>
-
-<Warning>
-  자격 증명을 저장소에 **절대** 커밋하지 마세요. 모든 비밀 정보에는 AMP 환경 변수를 사용하세요.
-  `.env` 파일은 `.gitignore`에 포함되어야 합니다.
-</Warning>
-
-기존 배포의 자격 증명을 업데이트하려면 [Crew 업데이트하기 — 환경 변수](/ko/enterprise/guides/update-crew)를 참조하세요.
-
-## 전체 동작 흐름
-
-CrewAI AMP가 자동화를 빌드할 때, 해결 흐름은 다음과 같이 작동합니다:
-
-<Steps>
-  <Step title="빌드 시작">
-    AMP가 저장소를 가져오고 `pyproject.toml`과 `uv.lock`을 읽습니다.
-  </Step>
-  <Step title="UV가 의존성 해결">
-    UV가 `[tool.uv.sources]`를 읽어 각 패키지가 어떤 index에서 와야 하는지 결정합니다.
-  </Step>
-  <Step title="UV가 인증">
-    각 프라이빗 index에 대해 UV가 AMP에서 구성한 환경 변수에서
-    `UV_INDEX_{NAME}_USERNAME`과 `UV_INDEX_{NAME}_PASSWORD`를 조회합니다.
-  </Step>
-  <Step title="패키지 설치">
-    UV가 공개(PyPI) 및 프라이빗(레지스트리) 패키지를 모두 다운로드하고 설치합니다.
-  </Step>
-  <Step title="자동화 실행">
-    모든 의존성이 사용 가능한 상태에서 crew 또는 flow가 시작됩니다.
-  </Step>
-</Steps>
-
-## 문제 해결
-
-### 빌드 중 인증 오류
-
-**증상**: 프라이빗 패키지를 해결할 때 `401 Unauthorized` 또는 `403 Forbidden`으로 빌드가 실패합니다.
-
-**확인사항**:
-- `UV_INDEX_*` 환경 변수 이름이 index 이름과 정확히 일치하는지 확인합니다 (대문자, 하이픈 -> 언더스코어)
-- 자격 증명이 로컬 `.env`뿐만 아니라 AMP 환경 변수에 설정되어 있는지 확인합니다
-- 토큰/PAT에 패키지 피드에 필요한 읽기 권한이 있는지 확인합니다
-- 토큰이 만료되지 않았는지 확인합니다 (특히 AWS CodeArtifact의 경우)
-
-### 패키지를 찾을 수 없음
-
-**증상**: `No matching distribution found for my-private-package`.
-
-**확인사항**:
-- `pyproject.toml`의 index URL이 `/simple/`로 끝나는지 확인합니다
-- `[tool.uv.sources]` 항목이 올바른 패키지 이름을 올바른 index 이름에 매핑하는지 확인합니다
-- 패키지가 실제로 프라이빗 레지스트리에 게시되어 있는지 확인합니다
-- 동일한 자격 증명으로 로컬에서 `uv lock`을 실행하여 해결이 작동하는지 확인합니다
-
-### Lock 파일 충돌
-
-**증상**: 프라이빗 index를 추가한 후 `uv lock`이 실패하거나 예상치 못한 결과를 생성합니다.
-
-**해결책**: 로컬에서 자격 증명을 설정하고 다시 생성합니다:
-
-```bash
-export UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
-export UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat
-uv lock
-```
-
-그런 다음 업데이트된 `uv.lock`을 커밋합니다.
-
-## 관련 가이드
-
-<CardGroup cols={3}>
-  <Card title="배포 준비하기" icon="clipboard-check" href="/ko/enterprise/guides/prepare-for-deployment">
-    배포 전에 프로젝트 구조와 의존성을 확인합니다.
-  </Card>
-  <Card title="AMP에 배포하기" icon="rocket" href="/ko/enterprise/guides/deploy-to-amp">
-    crew 또는 flow를 배포하고 환경 변수를 구성합니다.
-  </Card>
-  <Card title="Crew 업데이트하기" icon="arrows-rotate" href="/ko/enterprise/guides/update-crew">
-    환경 변수를 업데이트하고 실행 중인 배포에 변경 사항을 푸시합니다.
-  </Card>
-</CardGroup>

docs/ko/learn/human-feedback-in-flows.mdx

@@ -73,8 +73,6 @@ flow.kickoff()
 | `default_outcome` | `str` | 아니오 | 피드백이 제공되지 않을 때 사용할 outcome. `emit`에 있어야 합니다 |
 | `metadata` | `dict` | 아니오 | 엔터프라이즈 통합을 위한 추가 데이터 |
 | `provider` | `HumanFeedbackProvider` | 아니오 | 비동기/논블로킹 피드백을 위한 커스텀 프로바이더. [비동기 인간 피드백](#비동기-인간-피드백-논블로킹) 참조 |
-| `learn` | `bool` | 아니오 | HITL 학습 활성화: 피드백에서 교훈을 추출하고 향후 출력을 사전 검토합니다. 기본값 `False`. [피드백에서 학습하기](#피드백에서-학습하기) 참조 |
-| `learn_limit` | `int` | 아니오 | 사전 검토를 위해 불러올 최대 과거 교훈 수. 기본값 `5` |
 
 ### 기본 사용법 (라우팅 없음)
 
@@ -98,43 +96,33 @@ def handle_feedback(self, result):
 `emit`을 지정하면, 데코레이터는 라우터가 됩니다. 인간의 자유 형식 피드백이 LLM에 의해 해석되어 지정된 outcome 중 하나로 매핑됩니다:
 
 ```python Code
-from crewai.flow.flow import Flow, start, listen, or_
-from crewai.flow.human_feedback import human_feedback
+@start()
+@human_feedback(
+    message="이 콘텐츠의 출판을 승인하시겠습니까?",
+    emit=["approved", "rejected", "needs_revision"],
+    llm="gpt-4o-mini",
+    default_outcome="needs_revision",
+)
+def review_content(self):
+    return "블로그 게시물 초안 내용..."
 
-class ReviewFlow(Flow):
-    @start()
-    def generate_content(self):
-        return "블로그 게시물 초안 내용..."
+@listen("approved")
+def publish(self, result):
+    print(f"출판 중! 사용자 의견: {result.feedback}")
 
-    @human_feedback(
-        message="이 콘텐츠의 출판을 승인하시겠습니까?",
-        emit=["approved", "rejected", "needs_revision"],
-        llm="gpt-4o-mini",
-        default_outcome="needs_revision",
-    )
-    @listen(or_("generate_content", "needs_revision"))
-    def review_content(self):
-        return "블로그 게시물 초안 내용..."
+@listen("rejected")
+def discard(self, result):
+    print(f"폐기됨. 이유: {result.feedback}")
 
-    @listen("approved")
-    def publish(self, result):
-        print(f"출판 중! 사용자 의견: {result.feedback}")
-
-    @listen("rejected")
-    def discard(self, result):
-        print(f"폐기됨. 이유: {result.feedback}")
+@listen("needs_revision")
+def revise(self, result):
+    print(f"다음을 기반으로 수정 중: {result.feedback}")
 ```
 
-사용자가 "더 자세한 내용이 필요합니다"와 같이 말하면, LLM이 이를 `"needs_revision"`으로 매핑하고, `or_()`를 통해 `review_content`가 다시 트리거됩니다 — 수정 루프가 생성됩니다. outcome이 `"approved"` 또는 `"rejected"`가 될 때까지 루프가 계속됩니다.
-
 <Tip>
 LLM은 가능한 경우 구조화된 출력(function calling)을 사용하여 응답이 지정된 outcome 중 하나임을 보장합니다. 이로 인해 라우팅이 신뢰할 수 있고 예측 가능해집니다.
 </Tip>
 
-<Warning>
-`@start()` 메서드는 flow 시작 시 한 번만 실행됩니다. 수정 루프가 필요한 경우, start 메서드를 review 메서드와 분리하고 review 메서드에 `@listen(or_("trigger", "revision_outcome"))`를 사용하여 self-loop을 활성화하세요.
-</Warning>
-
 ## HumanFeedbackResult
 
 `HumanFeedbackResult` 데이터클래스는 인간 피드백 상호작용에 대한 모든 정보를 포함합니다:
@@ -203,162 +191,116 @@ def summarize(self):
 <CodeGroup>
 
 ```python Code
-from crewai.flow.flow import Flow, start, listen, or_
+from crewai.flow.flow import Flow, start, listen
 from crewai.flow.human_feedback import human_feedback, HumanFeedbackResult
 from pydantic import BaseModel
 
 
 class ContentState(BaseModel):
+    topic: str = ""
     draft: str = ""
+    final_content: str = ""
     revision_count: int = 0
-    status: str = "pending"
 
 
 class ContentApprovalFlow(Flow[ContentState]):
-    """콘텐츠를 생성하고 승인될 때까지 반복하는 Flow."""
+    """콘텐츠를 생성하고 인간의 승인을 받는 Flow입니다."""
 
     @start()
-    def generate_draft(self):
-        self.state.draft = "# AI 안전\n\nAI 안전에 대한 초안..."
+    def get_topic(self):
+        self.state.topic = input("어떤 주제에 대해 글을 쓸까요? ")
+        return self.state.topic
+
+    @listen(get_topic)
+    def generate_draft(self, topic):
+        # 실제 사용에서는 LLM을 호출합니다
+        self.state.draft = f"# {topic}\n\n{topic}에 대한 초안입니다..."
         return self.state.draft
 
+    @listen(generate_draft)
     @human_feedback(
-        message="이 초안을 검토해 주세요. 승인, 거부 또는 변경이 필요한 사항을 설명해 주세요:",
+        message="이 초안을 검토해 주세요. 'approved', 'rejected'로 답하거나 수정 피드백을 제공해 주세요:",
         emit=["approved", "rejected", "needs_revision"],
         llm="gpt-4o-mini",
         default_outcome="needs_revision",
     )
-    @listen(or_("generate_draft", "needs_revision"))
-    def review_draft(self):
-        self.state.revision_count += 1
-        return f"{self.state.draft} (v{self.state.revision_count})"
+    def review_draft(self, draft):
+        return draft
 
     @listen("approved")
     def publish_content(self, result: HumanFeedbackResult):
-        self.state.status = "published"
-        print(f"콘텐츠 승인 및 게시! 리뷰어 의견: {result.feedback}")
+        self.state.final_content = result.output
+        print("\n✅ 콘텐츠가 승인되어 출판되었습니다!")
+        print(f"검토자 코멘트: {result.feedback}")
         return "published"
 
     @listen("rejected")
     def handle_rejection(self, result: HumanFeedbackResult):
-        self.state.status = "rejected"
-        print(f"콘텐츠 거부됨. 이유: {result.feedback}")
+        print("\n❌ 콘텐츠가 거부되었습니다")
+        print(f"이유: {result.feedback}")
         return "rejected"
 
+    @listen("needs_revision")
+    def revise_content(self, result: HumanFeedbackResult):
+        self.state.revision_count += 1
+        print(f"\n📝 수정 #{self.state.revision_count} 요청됨")
+        print(f"피드백: {result.feedback}")
 
+        # 실제 Flow에서는 generate_draft로 돌아갈 수 있습니다
+        # 이 예제에서는 단순히 확인합니다
+        return "revision_requested"
+
+
+# Flow 실행
 flow = ContentApprovalFlow()
 result = flow.kickoff()
-print(f"\nFlow 완료. 상태: {flow.state.status}, 검토 횟수: {flow.state.revision_count}")
+print(f"\nFlow 완료. 요청된 수정: {flow.state.revision_count}")
 ```
 
 ```text Output
-==================================================
-OUTPUT FOR REVIEW:
-==================================================
-# AI 안전
-
-AI 안전에 대한 초안... (v1)
-==================================================
-
-이 초안을 검토해 주세요. 승인, 거부 또는 변경이 필요한 사항을 설명해 주세요:
-(Press Enter to skip, or type your feedback)
-
-Your feedback: 더 자세한 내용이 필요합니다
+어떤 주제에 대해 글을 쓸까요? AI 안전
 
 ==================================================
 OUTPUT FOR REVIEW:
 ==================================================
 # AI 안전
 
-AI 안전에 대한 초안... (v2)
+AI 안전에 대한 초안입니다...
 ==================================================
 
-이 초안을 검토해 주세요. 승인, 거부 또는 변경이 필요한 사항을 설명해 주세요:
+이 초안을 검토해 주세요. 'approved', 'rejected'로 답하거나 수정 피드백을 제공해 주세요:
 (Press Enter to skip, or type your feedback)
 
 Your feedback: 좋아 보입니다, 승인!
 
-콘텐츠 승인 및 게시! 리뷰어 의견: 좋아 보입니다, 승인!
+✅ 콘텐츠가 승인되어 출판되었습니다!
+검토자 코멘트: 좋아 보입니다, 승인!
 
-Flow 완료. 상태: published, 검토 횟수: 2
+Flow 완료. 요청된 수정: 0
 ```
 
 </CodeGroup>
 
 ## 다른 데코레이터와 결합하기
 
-`@human_feedback` 데코레이터는 `@start()`, `@listen()`, `or_()`와 함께 작동합니다. 데코레이터 순서는 두 가지 모두 동작합니다—프레임워크가 양방향으로 속성을 전파합니다—하지만 권장 패턴은 다음과 같습니다:
+`@human_feedback` 데코레이터는 다른 Flow 데코레이터와 함께 작동합니다. 가장 안쪽 데코레이터(함수에 가장 가까운)로 배치하세요:
 
 ```python Code
-# Flow 시작 시 일회성 검토 (self-loop 없음)
+# 올바름: @human_feedback이 가장 안쪽(함수에 가장 가까움)
 @start()
-@human_feedback(message="이것을 검토해 주세요:", emit=["approved", "rejected"], llm="gpt-4o-mini")
+@human_feedback(message="이것을 검토해 주세요:")
 def my_start_method(self):
     return "content"
 
-# 리스너에서 선형 검토 (self-loop 없음)
 @listen(other_method)
-@human_feedback(message="이것도 검토해 주세요:", emit=["good", "bad"], llm="gpt-4o-mini")
+@human_feedback(message="이것도 검토해 주세요:")
 def my_listener(self, data):
     return f"processed: {data}"
-
-# Self-loop: 수정을 위해 반복할 수 있는 검토
-@human_feedback(message="승인 또는 수정 요청?", emit=["approved", "revise"], llm="gpt-4o-mini")
-@listen(or_("upstream_method", "revise"))
-def review_with_loop(self):
-    return "content for review"
 ```
 
-### Self-loop 패턴
-
-수정 루프를 만들려면 `or_()`를 사용하여 검토 메서드가 **상위 트리거**와 **자체 수정 outcome**을 모두 리스닝해야 합니다:
-
-```python Code
-@start()
-def generate(self):
-    return "initial draft"
-
-@human_feedback(
-    message="승인하시겠습니까, 아니면 변경을 요청하시겠습니까?",
-    emit=["revise", "approved"],
-    llm="gpt-4o-mini",
-    default_outcome="approved",
-)
-@listen(or_("generate", "revise"))
-def review(self):
-    return "content"
-
-@listen("approved")
-def publish(self):
-    return "published"
-```
-
-outcome이 `"revise"`이면 flow가 `review`로 다시 라우팅됩니다 (`or_()`를 통해 `"revise"`를 리스닝하기 때문). outcome이 `"approved"`이면 flow가 `publish`로 계속됩니다. flow 엔진이 라우터를 "한 번만 실행" 규칙에서 제외하여 각 루프 반복마다 재실행할 수 있기 때문에 이 패턴이 동작합니다.
-
-### 체인된 라우터
-
-한 라우터의 outcome으로 트리거된 리스너가 그 자체로 라우터가 될 수 있습니다:
-
-```python Code
-@start()
-@human_feedback(message="첫 번째 검토:", emit=["approved", "rejected"], llm="gpt-4o-mini")
-def draft(self):
-    return "draft content"
-
-@listen("approved")
-@human_feedback(message="최종 검토:", emit=["publish", "revise"], llm="gpt-4o-mini")
-def final_review(self, prev):
-    return "final content"
-
-@listen("publish")
-def on_publish(self, prev):
-    return "published"
-```
-
-### 제한 사항
-
-- **`@start()` 메서드는 한 번만 실행**: `@start()` 메서드는 self-loop할 수 없습니다. 수정 주기가 필요하면 별도의 `@start()` 메서드를 진입점으로 사용하고 `@listen()` 메서드에 `@human_feedback`를 배치하세요.
-- **동일 메서드에 `@start()` + `@listen()` 불가**: 이는 Flow 프레임워크 제약입니다. 메서드는 시작점이거나 리스너여야 하며, 둘 다일 수 없습니다.
+<Tip>
+`@human_feedback`를 가장 안쪽 데코레이터(마지막/함수에 가장 가까움)로 배치하여 메서드를 직접 래핑하고 Flow 시스템에 전달하기 전에 반환 값을 캡처할 수 있도록 하세요.
+</Tip>
 
 ## 모범 사례
 
@@ -572,9 +514,9 @@ class ContentPipeline(Flow):
     @start()
     @human_feedback(
         message="이 콘텐츠의 출판을 승인하시겠습니까?",
-        emit=["approved", "rejected"],
+        emit=["approved", "rejected", "needs_revision"],
         llm="gpt-4o-mini",
-        default_outcome="rejected",
+        default_outcome="needs_revision",
         provider=SlackNotificationProvider("#content-reviews"),
     )
     def generate_content(self):
@@ -590,6 +532,11 @@ class ContentPipeline(Flow):
         print(f"보관됨. 이유: {result.feedback}")
         return {"status": "archived"}
 
+    @listen("needs_revision")
+    def queue_revision(self, result):
+        print(f"수정 대기열에 추가됨: {result.feedback}")
+        return {"status": "revision_needed"}
+
 
 # Flow 시작 (Slack 응답을 기다리며 일시 중지)
 def start_content_pipeline():
@@ -629,64 +576,6 @@ async def on_slack_feedback_async(flow_id: str, slack_message: str):
 5. **자동 영속성**: `HumanFeedbackPending`이 발생하면 상태가 자동으로 저장되며 기본적으로 `SQLiteFlowPersistence` 사용
 6. **커스텀 영속성**: 필요한 경우 `from_pending()`에 커스텀 영속성 인스턴스 전달
 
-## 피드백에서 학습하기
-
-`learn=True` 매개변수는 인간 검토자와 메모리 시스템 간의 피드백 루프를 활성화합니다. 활성화되면 시스템은 과거 인간의 수정 사항에서 학습하여 출력을 점진적으로 개선합니다.
-
-### 작동 방식
-
-1. **피드백 후**: LLM이 출력 + 피드백에서 일반화 가능한 교훈을 추출하고 `source="hitl"`로 메모리에 저장합니다. 피드백이 단순한 승인(예: "좋아 보입니다")인 경우 아무것도 저장하지 않습니다.
-2. **다음 검토 전**: 과거 HITL 교훈을 메모리에서 불러와 LLM이 인간이 보기 전에 출력을 개선하는 데 적용합니다.
-
-시간이 지남에 따라 각 수정 사항이 향후 검토에 반영되므로 인간은 점진적으로 더 나은 사전 검토된 출력을 보게 됩니다.
-
-### 예제
-
-```python Code
-class ArticleReviewFlow(Flow):
-    @start()
-    def generate_article(self):
-        return self.crew.kickoff(inputs={"topic": "AI Safety"}).raw
-
-    @human_feedback(
-        message="이 글 초안을 검토해 주세요:",
-        emit=["approved", "needs_revision"],
-        llm="gpt-4o-mini",
-        learn=True,
-    )
-    @listen(or_("generate_article", "needs_revision"))
-    def review_article(self):
-        return self.last_human_feedback.output if self.last_human_feedback else "article draft"
-
-    @listen("approved")
-    def publish(self):
-        print(f"Publishing: {self.last_human_feedback.output}")
-```
-
-**첫 번째 실행**: 인간이 원시 출력을 보고 "사실에 대한 주장에는 항상 인용을 포함하세요."라고 말합니다. 교훈이 추출되어 메모리에 저장됩니다.
-
-**두 번째 실행**: 시스템이 인용 교훈을 불러와 출력을 사전 검토하여 인용을 추가한 후 개선된 버전을 표시합니다. 인간의 역할이 "모든 것을 수정"에서 "시스템이 놓친 것을 찾기"로 전환됩니다.
-
-### 구성
-
-| 매개변수 | 기본값 | 설명 |
-|-----------|--------|------|
-| `learn` | `False` | HITL 학습 활성화 |
-| `learn_limit` | `5` | 사전 검토를 위해 불러올 최대 과거 교훈 수 |
-
-### 주요 설계 결정
-
-- **모든 것에 동일한 LLM 사용**: 데코레이터의 `llm` 매개변수는 outcome 매핑, 교훈 추출, 사전 검토에 공유됩니다. 여러 모델을 구성할 필요가 없습니다.
-- **구조화된 출력**: 추출과 사전 검토 모두 LLM이 지원하는 경우 Pydantic 모델과 함께 function calling을 사용하고, 그렇지 않으면 텍스트 파싱으로 폴백합니다.
-- **논블로킹 저장**: 교훈은 백그라운드 스레드에서 실행되는 `remember_many()`를 통해 저장됩니다 -- Flow는 즉시 계속됩니다.
-- **우아한 저하**: 추출 중 LLM이 실패하면 아무것도 저장하지 않습니다. 사전 검토 중 실패하면 원시 출력이 표시됩니다. 어느 쪽의 실패도 Flow를 차단하지 않습니다.
-- **범위/카테고리 불필요**: 교훈을 저장할 때 `source`만 전달됩니다. 인코딩 파이프라인이 범위, 카테고리, 중요도를 자동으로 추론합니다.
-
-<Note>
-`learn=True`는 Flow에 메모리가 사용 가능해야 합니다. Flow는 기본적으로 자동으로 메모리를 얻지만, `_skip_auto_memory`로 비활성화한 경우 HITL 학습은 조용히 건너뜁니다.
-</Note>
-
-
 ## 관련 문서
 
 - [Flow 개요](/ko/concepts/flows) - CrewAI Flow에 대해 알아보기
@@ -694,4 +583,3 @@ class ArticleReviewFlow(Flow):
 - [Flow 영속성](/ko/concepts/flows#persistence) - Flow 상태 영속화
 - [@router를 사용한 라우팅](/ko/concepts/flows#router) - 조건부 라우팅에 대해 더 알아보기
 - [실행 시 인간 입력](/ko/learn/human-input-on-execution) - 태스크 수준 인간 입력
-- [메모리](/ko/concepts/memory) - HITL 학습에서 사용되는 통합 메모리 시스템

docs/ko/learn/llm-connections.mdx

@@ -7,7 +7,7 @@ mode: "wide"
 
 ## CrewAI를 LLM에 연결하기
 
-CrewAI는 가장 인기 있는 제공자(OpenAI, Anthropic, Google Gemini, Azure, AWS Bedrock)에 대해 네이티브 SDK 통합을 통해 LLM에 연결하며, 그 외 모든 제공자에 대해서는 LiteLLM을 유연한 폴백으로 사용합니다.
+CrewAI는 LiteLLM을 사용하여 다양한 언어 모델(LLM)에 연결합니다. 이 통합은 높은 다양성을 제공하여, 여러 공급자의 모델을 간단하고 통합된 인터페이스로 사용할 수 있게 해줍니다.
 
 <Note>
     기본적으로 CrewAI는 `gpt-4o-mini` 모델을 사용합니다. 이는 `OPENAI_MODEL_NAME` 환경 변수에 의해 결정되며, 설정되지 않은 경우 기본값은 "gpt-4o-mini"입니다.
@@ -41,14 +41,6 @@ LiteLLM은 다음을 포함하되 이에 국한되지 않는 다양한 프로바
 
 지원되는 프로바이더의 전체 및 최신 목록은 [LiteLLM 프로바이더 문서](https://docs.litellm.ai/docs/providers)를 참조하세요.
 
-<Info>
-  네이티브 통합에서 지원하지 않는 제공자를 사용하려면 LiteLLM을 프로젝트에 의존성으로 추가하세요:
-  ```bash
-  uv add 'crewai[litellm]'
-  ```
-  네이티브 제공자(OpenAI, Anthropic, Google Gemini, Azure, AWS Bedrock)는 자체 SDK extras를 사용합니다 — [공급자 구성 예시](/ko/concepts/llms#공급자-구성-예시)를 참조하세요.
-</Info>
-
 ## LLM 변경하기
 
 CrewAI agent에서 다른 LLM을 사용하려면 여러 가지 방법이 있습니다:

docs/ko/observability/tracing.mdx

@@ -35,7 +35,7 @@ crewai login
 아직 설치하지 않았다면 CLI 도구와 함께 CrewAI를 설치하세요:
 
 ```bash
-uv add 'crewai[tools]'
+uv add crewai[tools]
 ```
 
 그런 다음 CrewAI AMP 계정으로 CLI를 인증하세요:

docs/ko/tools/automation/composiotool.mdx

@@ -18,46 +18,77 @@ Composio는 AI 에이전트를 250개 이상의 도구와 연결할 수 있는
 Composio 도구를 프로젝트에 통합하려면 아래 지침을 따르세요:
 
 ```shell
-pip install composio composio-crewai
+pip install composio-crewai
 pip install crewai
 ```
 
-설치가 완료되면 Composio API 키를 `COMPOSIO_API_KEY`로 설정하세요. Composio API 키는 [여기](https://platform.composio.dev)에서 받을 수 있습니다.
+설치가 완료된 후, `composio login`을 실행하거나 Composio API 키를 `COMPOSIO_API_KEY`로 export하세요. Composio API 키는 [여기](https://app.composio.dev)에서 받을 수 있습니다.
 
 ## 예시
 
-다음 예시는 도구를 초기화하고 GitHub 액션을 실행하는 방법을 보여줍니다:
+다음 예시는 도구를 초기화하고 github action을 실행하는 방법을 보여줍니다:
 
-1. CrewAI Provider와 함께 Composio 초기화
+1. Composio 도구 세트 초기화
 
 ```python Code
-from composio_crewai import ComposioProvider
-from composio import Composio
+from composio_crewai import ComposioToolSet, App, Action
 from crewai import Agent, Task, Crew
 
-composio = Composio(provider=ComposioProvider())
+toolset = ComposioToolSet()
 ```
 
-2. 새 Composio 세션을 만들고 도구 가져오기
+2. GitHub 계정 연결
 <CodeGroup>
-```python
-session = composio.create(
-    user_id="your-user-id",
-    toolkits=["gmail", "github"] # optional, default is all toolkits
-)
-tools = session.tools()
+```shell CLI
+composio add github
+```
+```python Code
+request = toolset.initiate_connection(app=App.GITHUB)
+print(f"Open this URL to authenticate: {request.redirectUrl}")
 ```
-세션 및 사용자 관리에 대한 자세한 내용은 [여기](https://docs.composio.dev/docs/configuring-sessions)를 참고하세요.
 </CodeGroup>
 
-3. 사용자 수동 인증하기
+3. 도구 가져오기
 
-Composio는 에이전트 채팅 세션 중에 사용자를 자동으로 인증합니다. 하지만 `authorize` 메서드를 호출해 사용자를 수동으로 인증할 수도 있습니다.
+- 앱에서 모든 도구를 가져오기 (프로덕션 환경에서는 권장하지 않음):
 ```python Code
-connection_request = session.authorize("github")
-print(f"Open this URL to authenticate: {connection_request.redirect_url}")
+tools = toolset.get_tools(apps=[App.GITHUB])
 ```
 
+- 태그를 기반으로 도구 필터링:
+```python Code
+tag = "users"
+
+filtered_action_enums = toolset.find_actions_by_tags(
+    App.GITHUB,
+    tags=[tag], 
+)
+
+tools = toolset.get_tools(actions=filtered_action_enums)
+```
+
+- 사용 사례를 기반으로 도구 필터링:
+```python Code
+use_case = "Star a repository on GitHub"
+
+filtered_action_enums = toolset.find_actions_by_use_case(
+    App.GITHUB, use_case=use_case, advanced=False
+)
+
+tools = toolset.get_tools(actions=filtered_action_enums)
+```
+<Tip>`advanced`를 True로 설정하면 복잡한 사용 사례를 위한 액션을 가져올 수 있습니다</Tip>
+
+- 특정 도구 사용하기:
+
+이 데모에서는 GitHub 앱의 `GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER` 액션을 사용합니다.
+```python Code
+tools = toolset.get_tools(
+    actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER]
+)
+```
+액션 필터링에 대해 더 자세한 내용을 보려면 [여기](https://docs.composio.dev/patterns/tools/use-tools/use-specific-actions)를 참고하세요.
+
 4. 에이전트 정의
 
 ```python Code
@@ -85,4 +116,4 @@ crew = Crew(agents=[crewai_agent], tasks=[task])
 crew.kickoff()
 ```
 
-* 더욱 자세한 도구 목록은 [여기](https://docs.composio.dev/toolkits)에서 확인할 수 있습니다.
+* 더욱 자세한 도구 리스트는 [여기](https://app.composio.dev)에서 확인하실 수 있습니다.

docs/pt-BR/changelog.mdx

@@ -4,106 +4,6 @@ description: "Atualizações de produto, melhorias e correções do CrewAI"
 icon: "clock"
 mode: "wide"
 ---
-<Update label="27 fev 2026">
-  ## v1.10.1a1
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## O que Mudou
-
-  ### Funcionalidades
-  - Implementar suporte a invocação assíncrona em métodos de callback de etapas
-  - Implementar carregamento sob demanda para dependências pesadas no módulo de Memória
-
-  ### Documentação
-  - Atualizar changelog e versão para v1.10.0
-
-  ### Refatoração
-  - Refatorar métodos de callback de etapas para suportar invocação assíncrona
-  - Refatorar para implementar carregamento sob demanda para dependências pesadas no módulo de Memória
-
-  ### Correções de Bugs
-  - Corrigir branch para notas de lançamento
-
-  ## Contribuidores
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
-<Update label="27 fev 2026">
-  ## v1.10.1a1
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## O que Mudou
-
-  ### Refatoração
-  - Refatorar métodos de callback de etapas para suportar invocação assíncrona
-  - Implementar carregamento sob demanda para dependências pesadas no módulo de Memória
-
-  ### Documentação
-  - Atualizar changelog e versão para v1.10.0
-
-  ### Correções de Bugs
-  - Criar branch para notas de lançamento
-
-  ## Contribuidores
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
-<Update label="26 fev 2026">
-  ## v1.10.0
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.0)
-
-  ## O que Mudou
-
-  ### Recursos
-  - Aprimorar a resolução da ferramenta MCP e eventos relacionados
-  - Atualizar a versão do lancedb e adicionar pacotes lance-namespace
-  - Aprimorar a análise e validação de argumentos JSON no CrewAgentExecutor e BaseTool
-  - Migrar o cliente HTTP da CLI de requests para httpx
-  - Adicionar documentação versionada
-  - Adicionar detecção de versões removidas para notas de versão
-  - Implementar tratamento de entrada do usuário em Flows
-  - Aprimorar a funcionalidade de auto-loop HITL nos testes de integração de feedback humano
-  - Adicionar started_event_id e definir no eventbus
-  - Atualizar automaticamente tools.specs
-
-  ### Correções de Bugs
-  - Validar kwargs da ferramenta mesmo quando vazios para evitar TypeError crípticos
-  - Preservar tipos nulos nos esquemas de parâmetros da ferramenta para LLM
-  - Mapear output_pydantic/output_json para saída estruturada nativa
-  - Garantir que callbacks sejam executados/aguardados se forem promessas
-  - Capturar o nome do método no contexto da exceção
-  - Preservar tipo enum no resultado do roteador; melhorar tipos
-  - Corrigir fluxos cíclicos que quebram silenciosamente quando o ID de persistência é passado nas entradas
-  - Corrigir o formato da flag da CLI de --skip-provider para --skip_provider
-  - Garantir que o fluxo de chamada da ferramenta OpenAI seja finalizado
-  - Resolver ponteiros $ref de esquema complexos nas ferramentas MCP
-  - Impor additionalProperties=false nos esquemas
-  - Rejeitar nomes de scripts reservados para pastas de equipe
-  - Resolver condição de corrida no teste de emissão de eventos de guardrail
-
-  ### Documentação
-  - Adicionar nota de dependência litellm para provedores de LLM não nativos
-  - Esclarecer o modelo de segurança NL2SQL e orientações de fortalecimento
-  - Adicionar 96 ações ausentes em 9 integrações
-
-  ### Refatoração
-  - Refatorar crew para provider
-  - Extrair HITL para padrão de provider
-  - Melhorar tipagem e registro de hooks
-
-  ## Contribuidores
-
-  @dependabot[bot], @github-actions[bot], @github-code-quality[bot], @greysonlalonde, @heitorado, @hobostay, @joaomdmoura, @johnvan7, @jonathansampson, @lorenzejay, @lucasgomide, @mattatcha, @mplachta, @nicoferdi96, @theCyberTech, @thiagomoretto, @vinibrsl
-
-</Update>
-
 <Update label="26 jan 2026">
   ## v1.9.0
 

docs/pt-BR/concepts/llms.mdx

@@ -105,15 +105,6 @@ Existem diferentes locais no código do CrewAI onde você pode especificar o mod
   </Tab>
 </Tabs>
 
-<Info>
-  O CrewAI oferece integrações nativas via SDK para OpenAI, Anthropic, Google (Gemini API), Azure e AWS Bedrock — sem necessidade de instalação extra além dos extras específicos do provedor (ex.: `uv add "crewai[openai]"`).
-
-  Todos os outros provedores são alimentados pelo **LiteLLM**. Se você planeja usar algum deles, adicione-o como dependência ao seu projeto:
-  ```bash
-  uv add 'crewai[litellm]'
-  ```
-</Info>
-
 ## Exemplos de Configuração de Provedores
 
 O CrewAI suporta uma grande variedade de provedores de LLM, cada um com recursos, métodos de autenticação e capacidades de modelo únicos.
@@ -223,11 +214,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
     | `meta_llama/Llama-4-Maverick-17B-128E-Instruct-FP8` | 128k | 4028 | Texto, Imagem | Texto |
     | `meta_llama/Llama-3.3-70B-Instruct` | 128k | 4028 | Texto | Texto |
     | `meta_llama/Llama-3.3-8B-Instruct` | 128k | 4028 | Texto | Texto |
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Anthropic">
@@ -368,11 +354,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
     | gemini-1.5-flash                 | 1M tokens          | Modelo multimodal equilibrado, bom para maioria das tarefas         |
     | gemini-1.5-flash-8B              | 1M tokens          | Mais rápido, mais eficiente em custo, adequado para tarefas de alta frequência |
     | gemini-1.5-pro                   | 2M tokens          | Melhor desempenho para uma ampla variedade de tarefas de raciocínio, incluindo lógica, codificação e colaboração criativa |
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Azure">
@@ -457,11 +438,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
         model="sagemaker/<my-endpoint>"
     )
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Mistral">
@@ -477,11 +453,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
         temperature=0.7
     )
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Nvidia NIM">
@@ -568,11 +539,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
     | rakuten/rakutenai-7b-instruct                                            | 1.024 tokens       | LLM topo de linha, compreensão, raciocínio e geração textual.|
     | rakuten/rakutenai-7b-chat                                                | 1.024 tokens       | LLM topo de linha, compreensão, raciocínio e geração textual.|
     | baichuan-inc/baichuan2-13b-chat                                          | 4.096 tokens       | Suporte a chat em chinês/inglês, programação, matemática, seguir instruções, resolver quizzes.|
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Local NVIDIA NIM Deployed using WSL2">
@@ -613,11 +579,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
 
         # ...
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Groq">
@@ -639,11 +600,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
     | Llama 3.1 70B/8B  | 131.072 tokens      | Alta performance e tarefas de contexto grande|
     | Llama 3.2 Série   | 8.192 tokens        | Tarefas gerais                          |
     | Mixtral 8x7B      | 32.768 tokens       | Equilíbrio entre performance e contexto  |
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="IBM watsonx.ai">
@@ -666,11 +622,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
         base_url="https://api.watsonx.ai/v1"
     )
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Ollama (LLMs Locais)">
@@ -684,11 +635,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
         base_url="http://localhost:11434"
     )
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Fireworks AI">
@@ -704,11 +650,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
         temperature=0.7
     )
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Perplexity AI">
@@ -724,11 +665,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
         base_url="https://api.perplexity.ai/"
     )
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Hugging Face">
@@ -743,11 +679,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
         model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct"
     )
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="SambaNova">
@@ -771,11 +702,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
     | Llama 3.2 Série   | 8.192 tokens              | Tarefas gerais e multimodais                 |
     | Llama 3.3 70B     | Até 131.072 tokens        | Desempenho e qualidade de saída elevada      |
     | Família Qwen2     | 8.192 tokens              | Desempenho e qualidade de saída elevada      |
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Cerebras">
@@ -801,11 +727,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
       - Equilíbrio entre velocidade e qualidade
       - Suporte a longas janelas de contexto
     </Info>
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Open Router">
@@ -828,11 +749,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
       - openrouter/deepseek/deepseek-r1
       - openrouter/deepseek/deepseek-chat
     </Info>
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 </AccordionGroup>
 

docs/pt-BR/enterprise/features/flow-hitl-management.mdx

@@ -38,21 +38,22 @@ O CrewAI Enterprise oferece um sistema abrangente de gerenciamento Human-in-the-
 Configure checkpoints de revisão humana em seus Flows usando o decorador `@human_feedback`. Quando a execução atinge um ponto de revisão, o sistema pausa, notifica o responsável via email e aguarda uma resposta.
 
 ```python
-from crewai.flow.flow import Flow, start, listen, or_
+from crewai.flow.flow import Flow, start, listen
 from crewai.flow.human_feedback import human_feedback, HumanFeedbackResult
 
 class ContentApprovalFlow(Flow):
     @start()
     def generate_content(self):
+        # IA gera conteúdo
         return "Texto de marketing gerado para campanha Q1..."
 
+    @listen(generate_content)
     @human_feedback(
         message="Por favor, revise este conteúdo para conformidade com a marca:",
         emit=["approved", "rejected", "needs_revision"],
     )
-    @listen(or_("generate_content", "needs_revision"))
-    def review_content(self):
-        return "Texto de marketing para revisão..."
+    def review_content(self, content):
+        return content
 
     @listen("approved")
     def publish_content(self, result: HumanFeedbackResult):
@@ -61,6 +62,10 @@ class ContentApprovalFlow(Flow):
     @listen("rejected")
     def archive_content(self, result: HumanFeedbackResult):
         print(f"Conteúdo rejeitado. Motivo: {result.feedback}")
+
+    @listen("needs_revision")
+    def revise_content(self, result: HumanFeedbackResult):
+        print(f"Revisão solicitada: {result.feedback}")
 ```
 
 Para detalhes completos de implementação, consulte o guia [Feedback Humano em Flows](/pt-BR/learn/human-feedback-in-flows).

docs/pt-BR/enterprise/guides/deploy-to-amp.mdx

@@ -176,11 +176,6 @@ Você precisa enviar seu crew para um repositório do GitHub. Caso ainda não te
       ![Definir Variáveis de Ambiente](/images/enterprise/set-env-variables.png)
     </Frame>
 
-    <Info>
-      Usando pacotes Python privados? Você também precisará adicionar suas credenciais de registro aqui.
-      Consulte [Registros de Pacotes Privados](/pt-BR/enterprise/guides/private-package-registry) para as variáveis necessárias.
-    </Info>
-
   </Step>
 
   <Step title="Implante Seu Crew">

docs/pt-BR/enterprise/guides/prepare-for-deployment.mdx

@@ -256,12 +256,6 @@ Antes da implantação, certifique-se de ter:
 1. **Chaves de API de LLM** prontas (OpenAI, Anthropic, Google, etc.)
 2. **Chaves de API de ferramentas** se estiver usando ferramentas externas (Serper, etc.)
 
-<Info>
-  Se seu projeto depende de pacotes de um **registro PyPI privado**, você também precisará configurar
-  credenciais de autenticação do registro como variáveis de ambiente. Consulte o guia
-  [Registros de Pacotes Privados](/pt-BR/enterprise/guides/private-package-registry) para mais detalhes.
-</Info>
-
 <Tip>
   Teste seu projeto localmente com as mesmas variáveis de ambiente antes de implantar
   para detectar problemas de configuração antecipadamente.

docs/pt-BR/enterprise/guides/private-package-registry.mdx

@@ -1,263 +0,0 @@
----
-title: "Registros de Pacotes Privados"
-description: "Instale pacotes Python privados de registros PyPI autenticados no CrewAI AMP"
-icon: "lock"
-mode: "wide"
----
-
-<Note>
-  Este guia aborda como configurar seu projeto CrewAI para instalar pacotes Python
-  de registros PyPI privados (Azure DevOps Artifacts, GitHub Packages, GitLab, AWS CodeArtifact, etc.)
-  ao implantar no CrewAI AMP.
-</Note>
-
-## Quando Você Precisa Disso
-
-Se seu projeto depende de pacotes Python internos ou proprietários hospedados em um registro privado
-em vez do PyPI público, você precisará:
-
-1. Informar ao UV **onde** encontrar o pacote (uma URL de index)
-2. Informar ao UV **quais** pacotes vêm desse index (um mapeamento de source)
-3. Fornecer **credenciais** para que o UV possa autenticar durante a instalação
-
-O CrewAI AMP usa [UV](https://docs.astral.sh/uv/) para resolução e instalação de dependências.
-O UV suporta registros privados autenticados por meio da configuração do `pyproject.toml` combinada
-com variáveis de ambiente para credenciais.
-
-## Passo 1: Configurar o pyproject.toml
-
-Três elementos trabalham juntos no seu `pyproject.toml`:
-
-### 1a. Declarar a dependência
-
-Adicione o pacote privado ao seu `[project.dependencies]` como qualquer outra dependência:
-
-```toml
-[project]
-dependencies = [
-    "crewai[tools]>=0.100.1,<1.0.0",
-    "my-private-package>=1.2.0",
-]
-```
-
-### 1b. Definir o index
-
-Registre seu registro privado como um index nomeado em `[[tool.uv.index]]`:
-
-```toml
-[[tool.uv.index]]
-name = "my-private-registry"
-url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
-explicit = true
-```
-
-<Info>
-  O campo `name` é importante — o UV o utiliza para construir os nomes das variáveis de ambiente
-  para autenticação (veja o [Passo 2](#passo-2-configurar-credenciais-de-autenticação) abaixo).
-
-  Definir `explicit = true` significa que o UV não consultará esse index para todos os pacotes — apenas
-  os que você mapear explicitamente em `[tool.uv.sources]`. Isso evita consultas desnecessárias
-  ao seu registro privado e protege contra ataques de confusão de dependências.
-</Info>
-
-### 1c. Mapear o pacote para o index
-
-Informe ao UV quais pacotes devem ser resolvidos a partir do seu index privado usando `[tool.uv.sources]`:
-
-```toml
-[tool.uv.sources]
-my-private-package = { index = "my-private-registry" }
-```
-
-### Exemplo completo
-
-```toml
-[project]
-name = "my-crew-project"
-version = "0.1.0"
-requires-python = ">=3.10,<=3.13"
-dependencies = [
-    "crewai[tools]>=0.100.1,<1.0.0",
-    "my-private-package>=1.2.0",
-]
-
-[tool.crewai]
-type = "crew"
-
-[[tool.uv.index]]
-name = "my-private-registry"
-url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
-explicit = true
-
-[tool.uv.sources]
-my-private-package = { index = "my-private-registry" }
-```
-
-Após atualizar o `pyproject.toml`, regenere seu arquivo lock:
-
-```bash
-uv lock
-```
-
-<Warning>
-  Sempre faça commit do `uv.lock` atualizado junto com as alterações no `pyproject.toml`.
-  O arquivo lock é obrigatório para implantação — veja [Preparar para Implantação](/pt-BR/enterprise/guides/prepare-for-deployment).
-</Warning>
-
-## Passo 2: Configurar Credenciais de Autenticação
-
-O UV autentica em indexes privados usando variáveis de ambiente que seguem uma convenção de nomenclatura
-baseada no nome do index que você definiu no `pyproject.toml`:
-
-```
-UV_INDEX_{UPPER_NAME}_USERNAME
-UV_INDEX_{UPPER_NAME}_PASSWORD
-```
-
-Onde `{UPPER_NAME}` é o nome do seu index convertido para **maiúsculas** com **hifens substituídos por underscores**.
-
-Por exemplo, um index chamado `my-private-registry` usa:
-
-| Variável | Valor |
-|----------|-------|
-| `UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME` | Seu nome de usuário ou nome do token do registro |
-| `UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD` | Sua senha ou token/PAT do registro |
-
-<Warning>
-  Essas variáveis de ambiente **devem** ser adicionadas pelas configurações de **Variáveis de Ambiente** do CrewAI AMP —
-  globalmente ou no nível da implantação. Elas não podem ser definidas em arquivos `.env` ou codificadas no seu projeto.
-
-  Veja [Configurar Variáveis de Ambiente no AMP](#configurar-variáveis-de-ambiente-no-amp) abaixo.
-</Warning>
-
-## Referência de Provedores de Registro
-
-A tabela abaixo mostra o formato da URL de index e os valores de credenciais para provedores de registro comuns.
-Substitua os valores de exemplo pelos detalhes reais da sua organização e feed.
-
-| Provedor | URL do Index | Usuário | Senha |
-|----------|-------------|---------|-------|
-| **Azure DevOps Artifacts** | `https://pkgs.dev.azure.com/{org}/_packaging/{feed}/pypi/simple/` | Qualquer string não vazia (ex: `token`) | Personal Access Token (PAT) com escopo Packaging Read |
-| **GitHub Packages** | `https://pypi.pkg.github.com/{owner}/simple/` | Nome de usuário do GitHub | Personal Access Token (classic) com escopo `read:packages` |
-| **GitLab Package Registry** | `https://gitlab.com/api/v4/projects/{project_id}/packages/pypi/simple/` | `__token__` | Project ou Personal Access Token com escopo `read_api` |
-| **AWS CodeArtifact** | Use a URL de `aws codeartifact get-repository-endpoint` | `aws` | Token de `aws codeartifact get-authorization-token` |
-| **Google Artifact Registry** | `https://{region}-python.pkg.dev/{project}/{repo}/simple/` | `_json_key_base64` | Chave de conta de serviço codificada em Base64 |
-| **JFrog Artifactory** | `https://{instance}.jfrog.io/artifactory/api/pypi/{repo}/simple/` | Nome de usuário ou email | Chave API ou token de identidade |
-| **Auto-hospedado (devpi, Nexus, etc.)** | URL da API simple do seu registro | Nome de usuário do registro | Senha do registro |
-
-<Tip>
-  Para **AWS CodeArtifact**, o token de autorização expira periodicamente.
-  Você precisará atualizar o valor de `UV_INDEX_*_PASSWORD` quando ele expirar.
-  Considere automatizar isso no seu pipeline de CI/CD.
-</Tip>
-
-## Configurar Variáveis de Ambiente no AMP
-
-As credenciais do registro privado devem ser configuradas como variáveis de ambiente no CrewAI AMP.
-Você tem duas opções:
-
-<Tabs>
-  <Tab title="Interface Web">
-    1. Faça login no [CrewAI AMP](https://app.crewai.com)
-    2. Navegue até sua automação
-    3. Abra a aba **Environment Variables**
-    4. Adicione cada variável (`UV_INDEX_*_USERNAME` e `UV_INDEX_*_PASSWORD`) com seu valor
-
-    Veja o passo [Deploy para AMP — Definir Variáveis de Ambiente](/pt-BR/enterprise/guides/deploy-to-amp#definir-as-variáveis-de-ambiente) para detalhes.
-  </Tab>
-  <Tab title="Implantação via CLI">
-    Adicione as variáveis ao seu arquivo `.env` local antes de executar `crewai deploy create`.
-    A CLI as transferirá com segurança para a plataforma:
-
-    ```bash
-    # .env
-    OPENAI_API_KEY=sk-...
-    UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
-    UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat-here
-    ```
-
-    ```bash
-    crewai deploy create
-    ```
-  </Tab>
-</Tabs>
-
-<Warning>
-  **Nunca** faça commit de credenciais no seu repositório. Use variáveis de ambiente do AMP para todos os segredos.
-  O arquivo `.env` deve estar listado no `.gitignore`.
-</Warning>
-
-Para atualizar credenciais em uma implantação existente, veja [Atualizar Seu Crew — Variáveis de Ambiente](/pt-BR/enterprise/guides/update-crew).
-
-## Como Tudo se Conecta
-
-Quando o CrewAI AMP faz o build da sua automação, o fluxo de resolução funciona assim:
-
-<Steps>
-  <Step title="Build inicia">
-    O AMP busca seu repositório e lê o `pyproject.toml` e o `uv.lock`.
-  </Step>
-  <Step title="UV resolve dependências">
-    O UV lê `[tool.uv.sources]` para determinar de qual index cada pacote deve vir.
-  </Step>
-  <Step title="UV autentica">
-    Para cada index privado, o UV busca `UV_INDEX_{NAME}_USERNAME` e `UV_INDEX_{NAME}_PASSWORD`
-    nas variáveis de ambiente que você configurou no AMP.
-  </Step>
-  <Step title="Pacotes são instalados">
-    O UV baixa e instala todos os pacotes — tanto públicos (do PyPI) quanto privados (do seu registro).
-  </Step>
-  <Step title="Automação executa">
-    Seu crew ou flow inicia com todas as dependências disponíveis.
-  </Step>
-</Steps>
-
-## Solução de Problemas
-
-### Erros de Autenticação Durante o Build
-
-**Sintoma**: Build falha com `401 Unauthorized` ou `403 Forbidden` ao resolver um pacote privado.
-
-**Verifique**:
-- Os nomes das variáveis de ambiente `UV_INDEX_*` correspondem exatamente ao nome do seu index (maiúsculas, hifens -> underscores)
-- As credenciais estão definidas nas variáveis de ambiente do AMP, não apenas em um `.env` local
-- Seu token/PAT tem as permissões de leitura necessárias para o feed de pacotes
-- O token não expirou (especialmente relevante para AWS CodeArtifact)
-
-### Pacote Não Encontrado
-
-**Sintoma**: `No matching distribution found for my-private-package`.
-
-**Verifique**:
-- A URL do index no `pyproject.toml` termina com `/simple/`
-- A entrada `[tool.uv.sources]` mapeia o nome correto do pacote para o nome correto do index
-- O pacote está realmente publicado no seu registro privado
-- Execute `uv lock` localmente com as mesmas credenciais para verificar se a resolução funciona
-
-### Conflitos no Arquivo Lock
-
-**Sintoma**: `uv lock` falha ou produz resultados inesperados após adicionar um index privado.
-
-**Solução**: Defina as credenciais localmente e regenere:
-
-```bash
-export UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
-export UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat
-uv lock
-```
-
-Em seguida, faça commit do `uv.lock` atualizado.
-
-## Guias Relacionados
-
-<CardGroup cols={3}>
-  <Card title="Preparar para Implantação" icon="clipboard-check" href="/pt-BR/enterprise/guides/prepare-for-deployment">
-    Verifique a estrutura do projeto e as dependências antes de implantar.
-  </Card>
-  <Card title="Deploy para AMP" icon="rocket" href="/pt-BR/enterprise/guides/deploy-to-amp">
-    Implante seu crew ou flow e configure variáveis de ambiente.
-  </Card>
-  <Card title="Atualizar Seu Crew" icon="arrows-rotate" href="/pt-BR/enterprise/guides/update-crew">
-    Atualize variáveis de ambiente e envie alterações para uma implantação em execução.
-  </Card>
-</CardGroup>

docs/pt-BR/learn/human-feedback-in-flows.mdx

@@ -73,8 +73,6 @@ Quando este flow é executado, ele irá:
 | `default_outcome` | `str` | Não | Outcome a usar se nenhum feedback for fornecido. Deve estar em `emit` |
 | `metadata` | `dict` | Não | Dados adicionais para integrações enterprise |
 | `provider` | `HumanFeedbackProvider` | Não | Provider customizado para feedback assíncrono/não-bloqueante. Veja [Feedback Humano Assíncrono](#feedback-humano-assíncrono-não-bloqueante) |
-| `learn` | `bool` | Não | Habilitar aprendizado HITL: destila lições do feedback e pré-revisa saídas futuras. Padrão `False`. Veja [Aprendendo com Feedback](#aprendendo-com-feedback) |
-| `learn_limit` | `int` | Não | Máximo de lições passadas para recuperar na pré-revisão. Padrão `5` |
 
 ### Uso Básico (Sem Roteamento)
 
@@ -98,43 +96,33 @@ def handle_feedback(self, result):
 Quando você especifica `emit`, o decorador se torna um roteador. O feedback livre do humano é interpretado por um LLM e mapeado para um dos outcomes especificados:
 
 ```python Code
-from crewai.flow.flow import Flow, start, listen, or_
-from crewai.flow.human_feedback import human_feedback
+@start()
+@human_feedback(
+    message="Você aprova este conteúdo para publicação?",
+    emit=["approved", "rejected", "needs_revision"],
+    llm="gpt-4o-mini",
+    default_outcome="needs_revision",
+)
+def review_content(self):
+    return "Rascunho do post do blog aqui..."
 
-class ReviewFlow(Flow):
-    @start()
-    def generate_content(self):
-        return "Rascunho do post do blog aqui..."
+@listen("approved")
+def publish(self, result):
+    print(f"Publicando! Usuário disse: {result.feedback}")
 
-    @human_feedback(
-        message="Você aprova este conteúdo para publicação?",
-        emit=["approved", "rejected", "needs_revision"],
-        llm="gpt-4o-mini",
-        default_outcome="needs_revision",
-    )
-    @listen(or_("generate_content", "needs_revision"))
-    def review_content(self):
-        return "Rascunho do post do blog aqui..."
+@listen("rejected")
+def discard(self, result):
+    print(f"Descartando. Motivo: {result.feedback}")
 
-    @listen("approved")
-    def publish(self, result):
-        print(f"Publicando! Usuário disse: {result.feedback}")
-
-    @listen("rejected")
-    def discard(self, result):
-        print(f"Descartando. Motivo: {result.feedback}")
+@listen("needs_revision")
+def revise(self, result):
+    print(f"Revisando baseado em: {result.feedback}")
 ```
 
-Quando o humano diz algo como "precisa de mais detalhes", o LLM mapeia para `"needs_revision"`, que dispara `review_content` novamente via `or_()` — criando um loop de revisão. O loop continua até que o outcome seja `"approved"` ou `"rejected"`.
-
 <Tip>
 O LLM usa saídas estruturadas (function calling) quando disponível para garantir que a resposta seja um dos seus outcomes especificados. Isso torna o roteamento confiável e previsível.
 </Tip>
 
-<Warning>
-Um método `@start()` só executa uma vez no início do flow. Se você precisa de um loop de revisão, separe o método start do método de revisão e use `@listen(or_("trigger", "revision_outcome"))` no método de revisão para habilitar o self-loop.
-</Warning>
-
 ## HumanFeedbackResult
 
 O dataclass `HumanFeedbackResult` contém todas as informações sobre uma interação de feedback humano:
@@ -203,162 +191,116 @@ Aqui está um exemplo completo implementando um fluxo de revisão e aprovação
 <CodeGroup>
 
 ```python Code
-from crewai.flow.flow import Flow, start, listen, or_
+from crewai.flow.flow import Flow, start, listen
 from crewai.flow.human_feedback import human_feedback, HumanFeedbackResult
 from pydantic import BaseModel
 
 
 class ContentState(BaseModel):
+    topic: str = ""
     draft: str = ""
+    final_content: str = ""
     revision_count: int = 0
-    status: str = "pending"
 
 
 class ContentApprovalFlow(Flow[ContentState]):
-    """Um flow que gera conteúdo e faz loop até o humano aprovar."""
+    """Um flow que gera conteúdo e obtém aprovação humana."""
 
     @start()
-    def generate_draft(self):
-        self.state.draft = "# IA Segura\n\nEste é um rascunho sobre IA Segura..."
+    def get_topic(self):
+        self.state.topic = input("Sobre qual tópico devo escrever? ")
+        return self.state.topic
+
+    @listen(get_topic)
+    def generate_draft(self, topic):
+        # Em uso real, isso chamaria um LLM
+        self.state.draft = f"# {topic}\n\nEste é um rascunho sobre {topic}..."
         return self.state.draft
 
+    @listen(generate_draft)
     @human_feedback(
-        message="Por favor, revise este rascunho. Aprove, rejeite ou descreva o que precisa mudar:",
+        message="Por favor, revise este rascunho. Responda 'approved', 'rejected', ou forneça feedback de revisão:",
         emit=["approved", "rejected", "needs_revision"],
         llm="gpt-4o-mini",
         default_outcome="needs_revision",
     )
-    @listen(or_("generate_draft", "needs_revision"))
-    def review_draft(self):
-        self.state.revision_count += 1
-        return f"{self.state.draft} (v{self.state.revision_count})"
+    def review_draft(self, draft):
+        return draft
 
     @listen("approved")
     def publish_content(self, result: HumanFeedbackResult):
-        self.state.status = "published"
-        print(f"Conteúdo aprovado e publicado! Revisor disse: {result.feedback}")
+        self.state.final_content = result.output
+        print("\n✅ Conteúdo aprovado e publicado!")
+        print(f"Comentário do revisor: {result.feedback}")
         return "published"
 
     @listen("rejected")
     def handle_rejection(self, result: HumanFeedbackResult):
-        self.state.status = "rejected"
-        print(f"Conteúdo rejeitado. Motivo: {result.feedback}")
+        print("\n❌ Conteúdo rejeitado")
+        print(f"Motivo: {result.feedback}")
         return "rejected"
 
+    @listen("needs_revision")
+    def revise_content(self, result: HumanFeedbackResult):
+        self.state.revision_count += 1
+        print(f"\n📝 Revisão #{self.state.revision_count} solicitada")
+        print(f"Feedback: {result.feedback}")
 
+        # Em um flow real, você pode voltar para generate_draft
+        # Para este exemplo, apenas reconhecemos
+        return "revision_requested"
+
+
+# Executar o flow
 flow = ContentApprovalFlow()
 result = flow.kickoff()
-print(f"\nFlow finalizado. Status: {flow.state.status}, Revisões: {flow.state.revision_count}")
+print(f"\nFlow concluído. Revisões solicitadas: {flow.state.revision_count}")
 ```
 
 ```text Output
-==================================================
-OUTPUT FOR REVIEW:
-==================================================
-# IA Segura
-
-Este é um rascunho sobre IA Segura... (v1)
-==================================================
-
-Por favor, revise este rascunho. Aprove, rejeite ou descreva o que precisa mudar:
-(Press Enter to skip, or type your feedback)
-
-Your feedback: Preciso de mais detalhes sobre segurança em IA.
+Sobre qual tópico devo escrever? Segurança em IA
 
 ==================================================
 OUTPUT FOR REVIEW:
 ==================================================
-# IA Segura
+# Segurança em IA
 
-Este é um rascunho sobre IA Segura... (v2)
+Este é um rascunho sobre Segurança em IA...
 ==================================================
 
-Por favor, revise este rascunho. Aprove, rejeite ou descreva o que precisa mudar:
+Por favor, revise este rascunho. Responda 'approved', 'rejected', ou forneça feedback de revisão:
 (Press Enter to skip, or type your feedback)
 
 Your feedback: Parece bom, aprovado!
 
-Conteúdo aprovado e publicado! Revisor disse: Parece bom, aprovado!
+✅ Conteúdo aprovado e publicado!
+Comentário do revisor: Parece bom, aprovado!
 
-Flow finalizado. Status: published, Revisões: 2
+Flow concluído. Revisões solicitadas: 0
 ```
 
 </CodeGroup>
 
 ## Combinando com Outros Decoradores
 
-O decorador `@human_feedback` funciona com `@start()`, `@listen()` e `or_()`. Ambas as ordens de decoradores funcionam — o framework propaga atributos em ambas as direções — mas os padrões recomendados são:
+O decorador `@human_feedback` funciona com outros decoradores de flow. Coloque-o como o decorador mais interno (mais próximo da função):
 
 ```python Code
-# Revisão única no início do flow (sem self-loop)
+# Correto: @human_feedback é o mais interno (mais próximo da função)
 @start()
-@human_feedback(message="Revise isto:", emit=["approved", "rejected"], llm="gpt-4o-mini")
+@human_feedback(message="Revise isto:")
 def my_start_method(self):
     return "content"
 
-# Revisão linear em um listener (sem self-loop)
 @listen(other_method)
-@human_feedback(message="Revise isto também:", emit=["good", "bad"], llm="gpt-4o-mini")
+@human_feedback(message="Revise isto também:")
 def my_listener(self, data):
     return f"processed: {data}"
-
-# Self-loop: revisão que pode voltar para revisões
-@human_feedback(message="Aprovar ou revisar?", emit=["approved", "revise"], llm="gpt-4o-mini")
-@listen(or_("upstream_method", "revise"))
-def review_with_loop(self):
-    return "content for review"
 ```
 
-### Padrão de self-loop
-
-Para criar um loop de revisão, o método de revisão deve escutar **ambos** um gatilho upstream e seu próprio outcome de revisão usando `or_()`:
-
-```python Code
-@start()
-def generate(self):
-    return "initial draft"
-
-@human_feedback(
-    message="Aprovar ou solicitar alterações?",
-    emit=["revise", "approved"],
-    llm="gpt-4o-mini",
-    default_outcome="approved",
-)
-@listen(or_("generate", "revise"))
-def review(self):
-    return "content"
-
-@listen("approved")
-def publish(self):
-    return "published"
-```
-
-Quando o outcome é `"revise"`, o flow roteia de volta para `review` (porque ele escuta `"revise"` via `or_()`). Quando o outcome é `"approved"`, o flow continua para `publish`. Isso funciona porque o engine de flow isenta roteadores da regra "fire once", permitindo que eles re-executem em cada iteração do loop.
-
-### Roteadores encadeados
-
-Um listener disparado pelo outcome de um roteador pode ser ele mesmo um roteador:
-
-```python Code
-@start()
-@human_feedback(message="Primeira revisão:", emit=["approved", "rejected"], llm="gpt-4o-mini")
-def draft(self):
-    return "draft content"
-
-@listen("approved")
-@human_feedback(message="Revisão final:", emit=["publish", "revise"], llm="gpt-4o-mini")
-def final_review(self, prev):
-    return "final content"
-
-@listen("publish")
-def on_publish(self, prev):
-    return "published"
-```
-
-### Limitações
-
-- **Métodos `@start()` executam uma vez**: Um método `@start()` não pode fazer self-loop. Se você precisa de um ciclo de revisão, use um método `@start()` separado como ponto de entrada e coloque o `@human_feedback` em um método `@listen()`.
-- **Sem `@start()` + `@listen()` no mesmo método**: Esta é uma restrição do framework de Flow. Um método é ou um ponto de início ou um listener, não ambos.
+<Tip>
+Coloque `@human_feedback` como o decorador mais interno (último/mais próximo da função) para que ele envolva o método diretamente e possa capturar o valor de retorno antes de passar para o sistema de flow.
+</Tip>
 
 ## Melhores Práticas
 
@@ -572,9 +514,9 @@ class ContentPipeline(Flow):
     @start()
     @human_feedback(
         message="Aprova este conteúdo para publicação?",
-        emit=["approved", "rejected"],
+        emit=["approved", "rejected", "needs_revision"],
         llm="gpt-4o-mini",
-        default_outcome="rejected",
+        default_outcome="needs_revision",
         provider=SlackNotificationProvider("#content-reviews"),
     )
     def generate_content(self):
@@ -590,6 +532,11 @@ class ContentPipeline(Flow):
         print(f"Arquivado. Motivo: {result.feedback}")
         return {"status": "archived"}
 
+    @listen("needs_revision")
+    def queue_revision(self, result):
+        print(f"Na fila para revisão: {result.feedback}")
+        return {"status": "revision_needed"}
+
 
 # Iniciando o flow (vai pausar e aguardar resposta do Slack)
 def start_content_pipeline():
@@ -629,64 +576,6 @@ Se você está usando um framework web assíncrono (FastAPI, aiohttp, Slack Bolt
 5. **Persistência automática**: O estado é automaticamente salvo quando `HumanFeedbackPending` é lançado e usa `SQLiteFlowPersistence` por padrão
 6. **Persistência customizada**: Passe uma instância de persistência customizada para `from_pending()` se necessário
 
-## Aprendendo com Feedback
-
-O parâmetro `learn=True` habilita um ciclo de feedback entre revisores humanos e o sistema de memória. Quando habilitado, o sistema melhora progressivamente suas saídas aprendendo com correções humanas anteriores.
-
-### Como Funciona
-
-1. **Após o feedback**: O LLM extrai lições generalizáveis da saída + feedback e as armazena na memória com `source="hitl"`. Se o feedback for apenas aprovação (ex: "parece bom"), nada é armazenado.
-2. **Antes da próxima revisão**: Lições HITL passadas são recuperadas da memória e aplicadas pelo LLM para melhorar a saída antes que o humano a veja.
-
-Com o tempo, o humano vê saídas pré-revisadas progressivamente melhores porque cada correção informa revisões futuras.
-
-### Exemplo
-
-```python Code
-class ArticleReviewFlow(Flow):
-    @start()
-    def generate_article(self):
-        return self.crew.kickoff(inputs={"topic": "AI Safety"}).raw
-
-    @human_feedback(
-        message="Revise este rascunho do artigo:",
-        emit=["approved", "needs_revision"],
-        llm="gpt-4o-mini",
-        learn=True,  # enable HITL learning
-    )
-    @listen(or_("generate_article", "needs_revision"))
-    def review_article(self):
-        return self.last_human_feedback.output if self.last_human_feedback else "article draft"
-
-    @listen("approved")
-    def publish(self):
-        print(f"Publishing: {self.last_human_feedback.output}")
-```
-
-**Primeira execução**: O humano vê a saída bruta e diz "Sempre inclua citações para afirmações factuais." A lição é destilada e armazenada na memória.
-
-**Segunda execução**: O sistema recupera a lição sobre citações, pré-revisa a saída para adicionar citações e então mostra a versão melhorada. O trabalho do humano muda de "corrigir tudo" para "identificar o que o sistema deixou passar."
-
-### Configuração
-
-| Parâmetro | Padrão | Descrição |
-|-----------|--------|-----------|
-| `learn` | `False` | Habilitar aprendizado HITL |
-| `learn_limit` | `5` | Máximo de lições passadas para recuperar na pré-revisão |
-
-### Decisões de Design Principais
-
-- **Mesmo LLM para tudo**: O parâmetro `llm` no decorador é compartilhado pelo mapeamento de outcome, destilação de lições e pré-revisão. Não é necessário configurar múltiplos modelos.
-- **Saída estruturada**: Tanto a destilação quanto a pré-revisão usam function calling com modelos Pydantic quando o LLM suporta, com fallback para parsing de texto caso contrário.
-- **Armazenamento não-bloqueante**: Lições são armazenadas via `remember_many()` que executa em uma thread em segundo plano -- o flow continua imediatamente.
-- **Degradação graciosa**: Se o LLM falhar durante a destilação, nada é armazenado. Se falhar durante a pré-revisão, a saída bruta é mostrada. Nenhuma falha bloqueia o flow.
-- **Sem escopo/categorias necessários**: Ao armazenar lições, apenas `source` é passado. O pipeline de codificação infere escopo, categorias e importância automaticamente.
-
-<Note>
-`learn=True` requer que o Flow tenha memória disponível. Flows obtêm memória automaticamente por padrão, mas se você a desabilitou com `_skip_auto_memory`, o aprendizado HITL será silenciosamente ignorado.
-</Note>
-
-
 ## Documentação Relacionada
 
 - [Visão Geral de Flows](/pt-BR/concepts/flows) - Aprenda sobre CrewAI Flows
@@ -694,4 +583,3 @@ class ArticleReviewFlow(Flow):
 - [Persistência de Flows](/pt-BR/concepts/flows#persistence) - Persistindo estado de flows
 - [Roteamento com @router](/pt-BR/concepts/flows#router) - Mais sobre roteamento condicional
 - [Input Humano na Execução](/pt-BR/learn/human-input-on-execution) - Input humano no nível de task
-- [Memória](/pt-BR/concepts/memory) - O sistema unificado de memória usado pelo aprendizado HITL

docs/pt-BR/learn/llm-connections.mdx

@@ -7,7 +7,7 @@ mode: "wide"
 
 ## Conecte o CrewAI a LLMs
 
-O CrewAI conecta-se a LLMs por meio de integrações nativas via SDK para os provedores mais populares (OpenAI, Anthropic, Google Gemini, Azure e AWS Bedrock), e usa o LiteLLM como alternativa flexível para todos os demais provedores.
+O CrewAI utiliza o LiteLLM para conectar-se a uma grande variedade de Modelos de Linguagem (LLMs). Essa integração proporciona grande versatilidade, permitindo que você utilize modelos de inúmeros provedores por meio de uma interface simples e unificada.
 
 <Note>
     Por padrão, o CrewAI usa o modelo `gpt-4o-mini`. Isso é determinado pela variável de ambiente `OPENAI_MODEL_NAME`, que tem como padrão "gpt-4o-mini" se não for definida.
@@ -40,14 +40,6 @@ O LiteLLM oferece suporte a uma ampla gama de provedores, incluindo, mas não se
 
 Para uma lista completa e sempre atualizada dos provedores suportados, consulte a [documentação de Provedores do LiteLLM](https://docs.litellm.ai/docs/providers).
 
-<Info>
-  Para usar qualquer provedor não coberto por uma integração nativa, adicione o LiteLLM como dependência ao seu projeto:
-  ```bash
-  uv add 'crewai[litellm]'
-  ```
-  Provedores nativos (OpenAI, Anthropic, Google Gemini, Azure, AWS Bedrock) usam seus próprios extras de SDK — consulte os [Exemplos de Configuração de Provedores](/pt-BR/concepts/llms#exemplos-de-configuração-de-provedores).
-</Info>
-
 ## Alterando a LLM
 
 Para utilizar uma LLM diferente com seus agentes CrewAI, você tem várias opções:

docs/pt-BR/tools/automation/composiotool.mdx

@@ -11,53 +11,84 @@ mode: "wide"
 Composio é uma plataforma de integração que permite conectar seus agentes de IA a mais de 250 ferramentas. Os principais recursos incluem:
 
 - **Autenticação de Nível Empresarial**: Suporte integrado para OAuth, Chaves de API, JWT com atualização automática de token
-- **Observabilidade Completa**: Logs detalhados de uso das ferramentas, carimbos de data/hora de execução e muito mais
+- **Observabilidade Completa**: Logs detalhados de uso das ferramentas, registros de execução, e muito mais
 
 ## Instalação
 
 Para incorporar as ferramentas Composio em seu projeto, siga as instruções abaixo:
 
 ```shell
-pip install composio composio-crewai
+pip install composio-crewai
 pip install crewai
 ```
 
-Após concluir a instalação, defina sua chave de API do Composio como `COMPOSIO_API_KEY`. Obtenha sua chave de API do Composio [aqui](https://platform.composio.dev)
+Após a conclusão da instalação, execute `composio login` ou exporte sua chave de API do composio como `COMPOSIO_API_KEY`. Obtenha sua chave de API Composio [aqui](https://app.composio.dev)
 
 ## Exemplo
 
-O exemplo a seguir demonstra como inicializar a ferramenta e executar uma ação do GitHub:
+O exemplo a seguir demonstra como inicializar a ferramenta e executar uma ação do github:
 
-1. Inicialize o Composio com o Provider do CrewAI
+1. Inicialize o conjunto de ferramentas Composio
 
 ```python Code
-from composio_crewai import ComposioProvider
-from composio import Composio
+from composio_crewai import ComposioToolSet, App, Action
 from crewai import Agent, Task, Crew
 
-composio = Composio(provider=ComposioProvider())
+toolset = ComposioToolSet()
 ```
 
-2. Crie uma nova sessão Composio e recupere as ferramentas
+2. Conecte sua conta do GitHub
 <CodeGroup>
-```python
-session = composio.create(
-    user_id="your-user-id",
-    toolkits=["gmail", "github"] # optional, default is all toolkits
-)
-tools = session.tools()
+```shell CLI
+composio add github
+```
+```python Code
+request = toolset.initiate_connection(app=App.GITHUB)
+print(f"Open this URL to authenticate: {request.redirectUrl}")
 ```
-Leia mais sobre sessões e gerenciamento de usuários [aqui](https://docs.composio.dev/docs/configuring-sessions)
 </CodeGroup>
 
-3. Autenticação manual dos usuários
+3. Obtenha ferramentas
 
-O Composio autentica automaticamente os usuários durante a sessão de chat do agente. No entanto, você também pode autenticar o usuário manualmente chamando o método `authorize`.
+- Recuperando todas as ferramentas de um app (não recomendado em produção):
 ```python Code
-connection_request = session.authorize("github")
-print(f"Open this URL to authenticate: {connection_request.redirect_url}")
+tools = toolset.get_tools(apps=[App.GITHUB])
 ```
 
+- Filtrando ferramentas com base em tags:
+```python Code
+tag = "users"
+
+filtered_action_enums = toolset.find_actions_by_tags(
+    App.GITHUB,
+    tags=[tag], 
+)
+
+tools = toolset.get_tools(actions=filtered_action_enums)
+```
+
+- Filtrando ferramentas com base no caso de uso:
+```python Code
+use_case = "Star a repository on GitHub"
+
+filtered_action_enums = toolset.find_actions_by_use_case(
+    App.GITHUB, use_case=use_case, advanced=False
+)
+
+tools = toolset.get_tools(actions=filtered_action_enums)
+```
+<Tip>Defina `advanced` como True para obter ações para casos de uso complexos</Tip>
+
+- Usando ferramentas específicas:
+
+Neste exemplo, usaremos a ação `GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER` do app GitHub.
+```python Code
+tools = toolset.get_tools(
+    actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER]
+)
+```
+Saiba mais sobre como filtrar ações [aqui](https://docs.composio.dev/patterns/tools/use-tools/use-specific-actions)
+
 4. Defina o agente
 
 ```python Code
@@ -85,4 +116,4 @@ crew = Crew(agents=[crewai_agent], tasks=[task])
 crew.kickoff()
 ```
 
-* Uma lista mais detalhada de ferramentas pode ser encontrada [aqui](https://docs.composio.dev/toolkits)
+* Uma lista mais detalhada de ferramentas pode ser encontrada [aqui](https://app.composio.dev)

lib/crewai-files/pyproject.toml

@@ -8,8 +8,8 @@ authors = [
 ]
 requires-python = ">=3.10, <3.14"
 dependencies = [
-    "Pillow~=12.1.1",
-    "pypdf~=6.7.4",
+    "Pillow~=10.4.0",
+    "pypdf~=4.0.0",
     "python-magic>=0.4.27",
     "aiocache~=0.12.3",
     "aiofiles~=24.1.0",

lib/crewai-files/src/crewai_files/__init__.py

@@ -152,4 +152,4 @@ __all__ = [
     "wrap_file_source",
 ]
 
-__version__ = "1.10.1a1"
+__version__ = "1.9.3"

lib/crewai-tools/pyproject.toml

@@ -8,10 +8,12 @@ authors = [
 ]
 requires-python = ">=3.10, <3.14"
 dependencies = [
+    "lancedb~=0.5.4",
     "pytube~=15.0.0",
     "requests~=2.32.5",
     "docker~=7.1.0",
-    "crewai==1.10.1a1",
+    "crewai==1.9.3",
+    "lancedb~=0.5.4",
     "tiktoken~=0.8.0",
     "beautifulsoup4~=4.13.4",
     "python-docx~=1.2.0",

lib/crewai-tools/src/crewai_tools/__init__.py

@@ -291,4 +291,4 @@ __all__ = [
     "ZapierActionTools",
 ]
 
-__version__ = "1.10.1a1"
+__version__ = "1.9.3"

lib/crewai-tools/tool.specs.json

@@ -20117,6 +20117,18 @@
       "humanized_name": "Web Automation Tool",
       "init_params_schema": {
         "$defs": {
+          "AvailableModel": {
+            "enum": [
+              "gpt-4o",
+              "gpt-4o-mini",
+              "claude-3-5-sonnet-latest",
+              "claude-3-7-sonnet-latest",
+              "computer-use-preview",
+              "gemini-2.0-flash"
+            ],
+            "title": "AvailableModel",
+            "type": "string"
+          },
           "EnvVar": {
             "properties": {
               "default": {
@@ -20194,6 +20206,17 @@
             "default": null,
             "title": "Model Api Key"
           },
+          "model_name": {
+            "anyOf": [
+              {
+                "$ref": "#/$defs/AvailableModel"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": "claude-3-7-sonnet-latest"
+          },
           "project_id": {
             "anyOf": [
               {

lib/crewai/pyproject.toml

@@ -16,9 +16,9 @@ dependencies = [
     "pdfplumber~=0.11.4",
     "regex~=2026.1.15",
     # Telemetry and Monitoring
-    "opentelemetry-api~=1.34.0",
-    "opentelemetry-sdk~=1.34.0",
-    "opentelemetry-exporter-otlp-proto-http~=1.34.0",
+    "opentelemetry-api>=1.34.0,<2",
+    "opentelemetry-sdk>=1.34.0,<2",
+    "opentelemetry-exporter-otlp-proto-http>=1.34.0,<2",
     # Data Handling
     "chromadb~=1.1.0",
     "tokenizers~=0.20.3",
@@ -26,8 +26,6 @@ dependencies = [
     # Authentication and Security
     "python-dotenv~=1.1.1",
     "pyjwt>=2.9.0,<3",
-    # TUI
-    "textual>=7.5.0",
     # Configuration and Utils
     "click~=8.1.7",
     "appdirs~=1.4.4",
@@ -38,11 +36,9 @@ dependencies = [
     "json5~=0.10.0",
     "portalocker~=2.7.0",
     "pydantic-settings~=2.10.1",
-    "httpx~=0.28.1",
     "mcp~=1.26.0",
     "uv~=0.9.13",
     "aiosqlite~=0.21.0",
-    "lancedb>=0.29.2",
 ]
 
 [project.urls]
@@ -53,7 +49,7 @@ Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
 tools = [
-    "crewai-tools==1.10.1a1",
+    "crewai-tools==1.9.3",
 ]
 embeddings = [
     "tiktoken~=0.8.0"
@@ -66,7 +62,7 @@ openpyxl = [
 ]
 mem0 = ["mem0ai~=0.1.94"]
 docling = [
-    "docling~=2.75.0",
+    "docling~=2.63.0",
 ]
 qdrant = [
     "qdrant-client[fastembed]~=1.14.3",

lib/crewai/src/crewai/__init__.py

@@ -40,7 +40,7 @@ def _suppress_pydantic_deprecation_warnings() -> None:
 
 _suppress_pydantic_deprecation_warnings()
 
-__version__ = "1.10.1a1"
+__version__ = "1.9.3"
 _telemetry_submitted = False
 
 
@@ -71,25 +71,6 @@ def _track_install_async() -> None:
 
 
 _track_install_async()
-
-_LAZY_IMPORTS: dict[str, tuple[str, str]] = {
-    "Memory": ("crewai.memory.unified_memory", "Memory"),
-}
-
-
-def __getattr__(name: str) -> Any:
-    """Lazily import heavy modules (e.g. Memory → lancedb) on first access."""
-    if name in _LAZY_IMPORTS:
-        module_path, attr = _LAZY_IMPORTS[name]
-        import importlib
-
-        mod = importlib.import_module(module_path)
-        val = getattr(mod, attr)
-        globals()[name] = val
-        return val
-    raise AttributeError(f"module 'crewai' has no attribute {name!r}")
-
-
 __all__ = [
     "LLM",
     "Agent",
@@ -99,7 +80,6 @@ __all__ = [
     "Flow",
     "Knowledge",
     "LLMGuardrail",
-    "Memory",
     "Process",
     "Task",
     "TaskOutput",

lib/crewai/src/crewai/agent/core.py

@@ -8,9 +8,11 @@ import time
 from typing import (
     TYPE_CHECKING,
     Any,
+    Final,
     Literal,
     cast,
 )
+from urllib.parse import urlparse
 
 from pydantic import (
     BaseModel,
@@ -59,8 +61,17 @@ from crewai.knowledge.knowledge import Knowledge
 from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
 from crewai.lite_agent_output import LiteAgentOutput
 from crewai.llms.base_llm import BaseLLM
-from crewai.mcp import MCPServerConfig
-from crewai.mcp.tool_resolver import MCPToolResolver
+from crewai.mcp import (
+    MCPClient,
+    MCPServerConfig,
+    MCPServerHTTP,
+    MCPServerSSE,
+    MCPServerStdio,
+)
+from crewai.mcp.transports.http import HTTPTransport
+from crewai.mcp.transports.sse import SSETransport
+from crewai.mcp.transports.stdio import StdioTransport
+from crewai.memory.contextual.contextual_memory import ContextualMemory
 from crewai.rag.embeddings.types import EmbedderConfig
 from crewai.security.fingerprint import Fingerprint
 from crewai.tools.agent_tools.agent_tools import AgentTools
@@ -101,8 +112,18 @@ if TYPE_CHECKING:
     from crewai.utilities.types import LLMMessage
 
 
+# MCP Connection timeout constants (in seconds)
+MCP_CONNECTION_TIMEOUT: Final[int] = 10
+MCP_TOOL_EXECUTION_TIMEOUT: Final[int] = 30
+MCP_DISCOVERY_TIMEOUT: Final[int] = 15
+MCP_MAX_RETRIES: Final[int] = 3
+
 _passthrough_exceptions: tuple[type[Exception], ...] = ()
 
+# Simple in-memory cache for MCP tool schemas (duration: 5 minutes)
+_mcp_schema_cache: dict[str, Any] = {}
+_cache_ttl: Final[int] = 300  # 5 minutes
+
 
 class Agent(BaseAgent):
     """Represents an agent in a system.
@@ -134,7 +155,7 @@ class Agent(BaseAgent):
     model_config = ConfigDict()
 
     _times_executed: int = PrivateAttr(default=0)
-    _mcp_resolver: MCPToolResolver | None = PrivateAttr(default=None)
+    _mcp_clients: list[Any] = PrivateAttr(default_factory=list)
     _last_messages: list[LLMMessage] = PrivateAttr(default_factory=list)
     max_execution_time: int | None = Field(
         default=None,
@@ -290,12 +311,19 @@ class Agent(BaseAgent):
             raise ValueError(f"Invalid Knowledge Configuration: {e!s}") from e
 
     def _is_any_available_memory(self) -> bool:
-        """Check if unified memory is available (agent or crew)."""
-        if getattr(self, "memory", None):
-            return True
-        if self.crew and getattr(self.crew, "_memory", None):
-            return True
-        return False
+        """Check if any memory is available."""
+        if not self.crew:
+            return False
+
+        memory_attributes = [
+            "memory",
+            "_short_term_memory",
+            "_long_term_memory",
+            "_entity_memory",
+            "_external_memory",
+        ]
+
+        return any(getattr(self.crew, attr) for attr in memory_attributes)
 
     def _supports_native_tool_calling(self, tools: list[BaseTool]) -> bool:
         """Check if the LLM supports native function calling with the given tools.
@@ -359,16 +387,15 @@ class Agent(BaseAgent):
             memory = ""
 
             try:
-                unified_memory = getattr(self, "memory", None) or (
-                    getattr(self.crew, "_memory", None) if self.crew else None
+                contextual_memory = ContextualMemory(
+                    self.crew._short_term_memory,
+                    self.crew._long_term_memory,
+                    self.crew._entity_memory,
+                    self.crew._external_memory,
+                    agent=self,
+                    task=task,
                 )
-                if unified_memory is not None:
-                    query = task.description
-                    matches = unified_memory.recall(query, limit=5)
-                    if matches:
-                        memory = "Relevant memories:\n" + "\n".join(
-                            m.format() for m in matches
-                        )
+                memory = contextual_memory.build_context_for_task(task, context or "")
                 if memory.strip() != "":
                     task_prompt += self.i18n.slice("memory").format(memory=memory)
 
@@ -597,16 +624,17 @@ class Agent(BaseAgent):
             memory = ""
 
             try:
-                unified_memory = getattr(self, "memory", None) or (
-                    getattr(self.crew, "_memory", None) if self.crew else None
+                contextual_memory = ContextualMemory(
+                    self.crew._short_term_memory,
+                    self.crew._long_term_memory,
+                    self.crew._entity_memory,
+                    self.crew._external_memory,
+                    agent=self,
+                    task=task,
+                )
+                memory = await contextual_memory.abuild_context_for_task(
+                    task, context or ""
                 )
-                if unified_memory is not None:
-                    query = task.description
-                    matches = unified_memory.recall(query, limit=5)
-                    if matches:
-                        memory = "Relevant memories:\n" + "\n".join(
-                            m.format() for m in matches
-                        )
                 if memory.strip() != "":
                     task_prompt += self.i18n.slice("memory").format(memory=memory)
 
@@ -844,11 +872,7 @@ class Agent(BaseAgent):
                 respect_context_window=self.respect_context_window,
                 request_within_rpm_limit=rpm_limit_fn,
                 callbacks=[TokenCalcHandler(self._token_process)],
-                response_model=(
-                    task.response_model or task.output_pydantic or task.output_json
-                )
-                if task
-                else None,
+                response_model=task.response_model if task else None,
             )
 
     def _update_executor_parameters(
@@ -877,11 +901,7 @@ class Agent(BaseAgent):
         self.agent_executor.stop = stop_words
         self.agent_executor.tools_names = get_tool_names(tools)
         self.agent_executor.tools_description = render_text_description_and_args(tools)
-        self.agent_executor.response_model = (
-            (task.response_model or task.output_pydantic or task.output_json)
-            if task
-            else None
-        )
+        self.agent_executor.response_model = task.response_model if task else None
 
         self.agent_executor.tools_handler = self.tools_handler
         self.agent_executor.request_within_rpm_limit = rpm_limit_fn
@@ -914,17 +934,544 @@ class Agent(BaseAgent):
     def get_mcp_tools(self, mcps: list[str | MCPServerConfig]) -> list[BaseTool]:
         """Convert MCP server references/configs to CrewAI tools.
 
-        Delegates to :class:`~crewai.mcp.tool_resolver.MCPToolResolver`.
+        Supports both string references (backwards compatible) and structured
+        configuration objects (MCPServerStdio, MCPServerHTTP, MCPServerSSE).
+
+        Args:
+            mcps: List of MCP server references (strings) or configurations.
+
+        Returns:
+            List of BaseTool instances from MCP servers.
         """
-        self._cleanup_mcp_clients()
-        self._mcp_resolver = MCPToolResolver(agent=self, logger=self._logger)
-        return self._mcp_resolver.resolve(mcps)
+        all_tools = []
+        clients = []
+
+        for mcp_config in mcps:
+            if isinstance(mcp_config, str):
+                tools = self._get_mcp_tools_from_string(mcp_config)
+            else:
+                tools, client = self._get_native_mcp_tools(mcp_config)
+                if client:
+                    clients.append(client)
+
+            all_tools.extend(tools)
+
+        # Store clients for cleanup
+        self._mcp_clients.extend(clients)
+        return all_tools
 
     def _cleanup_mcp_clients(self) -> None:
         """Cleanup MCP client connections after task execution."""
-        if self._mcp_resolver is not None:
-            self._mcp_resolver.cleanup()
-            self._mcp_resolver = None
+        if not self._mcp_clients:
+            return
+
+        async def _disconnect_all() -> None:
+            for client in self._mcp_clients:
+                if client and hasattr(client, "connected") and client.connected:
+                    await client.disconnect()
+
+        try:
+            asyncio.run(_disconnect_all())
+        except Exception as e:
+            self._logger.log("error", f"Error during MCP client cleanup: {e}")
+        finally:
+            self._mcp_clients.clear()
+
+    def _get_mcp_tools_from_string(self, mcp_ref: str) -> list[BaseTool]:
+        """Get tools from legacy string-based MCP references.
+
+        This method maintains backwards compatibility with string-based
+        MCP references (https://... and crewai-amp:...).
+
+        Args:
+            mcp_ref: String reference to MCP server.
+
+        Returns:
+            List of BaseTool instances.
+        """
+        if mcp_ref.startswith("crewai-amp:"):
+            return self._get_amp_mcp_tools(mcp_ref)
+        if mcp_ref.startswith("https://"):
+            return self._get_external_mcp_tools(mcp_ref)
+        return []
+
+    def _get_external_mcp_tools(self, mcp_ref: str) -> list[BaseTool]:
+        """Get tools from external HTTPS MCP server with graceful error handling."""
+        from crewai.tools.mcp_tool_wrapper import MCPToolWrapper
+
+        # Parse server URL and optional tool name
+        if "#" in mcp_ref:
+            server_url, specific_tool = mcp_ref.split("#", 1)
+        else:
+            server_url, specific_tool = mcp_ref, None
+
+        server_params = {"url": server_url}
+        server_name = self._extract_server_name(server_url)
+
+        try:
+            # Get tool schemas with timeout and error handling
+            tool_schemas = self._get_mcp_tool_schemas(server_params)
+
+            if not tool_schemas:
+                self._logger.log(
+                    "warning", f"No tools discovered from MCP server: {server_url}"
+                )
+                return []
+
+            tools = []
+            for tool_name, schema in tool_schemas.items():
+                # Skip if specific tool requested and this isn't it
+                if specific_tool and tool_name != specific_tool:
+                    continue
+
+                try:
+                    wrapper = MCPToolWrapper(
+                        mcp_server_params=server_params,
+                        tool_name=tool_name,
+                        tool_schema=schema,
+                        server_name=server_name,
+                    )
+                    tools.append(wrapper)
+                except Exception as e:
+                    self._logger.log(
+                        "warning",
+                        f"Failed to create MCP tool wrapper for {tool_name}: {e}",
+                    )
+                    continue
+
+            if specific_tool and not tools:
+                self._logger.log(
+                    "warning",
+                    f"Specific tool '{specific_tool}' not found on MCP server: {server_url}",
+                )
+
+            return cast(list[BaseTool], tools)
+
+        except Exception as e:
+            self._logger.log(
+                "warning", f"Failed to connect to MCP server {server_url}: {e}"
+            )
+            return []
+
+    def _get_native_mcp_tools(
+        self, mcp_config: MCPServerConfig
+    ) -> tuple[list[BaseTool], Any | None]:
+        """Get tools from MCP server using structured configuration.
+
+        This method creates an MCP client based on the configuration type,
+        connects to the server, discovers tools, applies filtering, and
+        returns wrapped tools along with the client instance for cleanup.
+
+        Args:
+            mcp_config: MCP server configuration (MCPServerStdio, MCPServerHTTP, or MCPServerSSE).
+
+        Returns:
+            Tuple of (list of BaseTool instances, MCPClient instance for cleanup).
+        """
+        from crewai.tools.base_tool import BaseTool
+        from crewai.tools.mcp_native_tool import MCPNativeTool
+
+        transport: StdioTransport | HTTPTransport | SSETransport
+        if isinstance(mcp_config, MCPServerStdio):
+            transport = StdioTransport(
+                command=mcp_config.command,
+                args=mcp_config.args,
+                env=mcp_config.env,
+            )
+            server_name = f"{mcp_config.command}_{'_'.join(mcp_config.args)}"
+        elif isinstance(mcp_config, MCPServerHTTP):
+            transport = HTTPTransport(
+                url=mcp_config.url,
+                headers=mcp_config.headers,
+                streamable=mcp_config.streamable,
+            )
+            server_name = self._extract_server_name(mcp_config.url)
+        elif isinstance(mcp_config, MCPServerSSE):
+            transport = SSETransport(
+                url=mcp_config.url,
+                headers=mcp_config.headers,
+            )
+            server_name = self._extract_server_name(mcp_config.url)
+        else:
+            raise ValueError(f"Unsupported MCP server config type: {type(mcp_config)}")
+
+        client = MCPClient(
+            transport=transport,
+            cache_tools_list=mcp_config.cache_tools_list,
+        )
+
+        async def _setup_client_and_list_tools() -> list[dict[str, Any]]:
+            """Async helper to connect and list tools in same event loop."""
+
+            try:
+                if not client.connected:
+                    await client.connect()
+
+                tools_list = await client.list_tools()
+
+                try:
+                    await client.disconnect()
+                    # Small delay to allow background tasks to finish cleanup
+                    # This helps prevent "cancel scope in different task" errors
+                    # when asyncio.run() closes the event loop
+                    await asyncio.sleep(0.1)
+                except Exception as e:
+                    self._logger.log("error", f"Error during disconnect: {e}")
+
+                return tools_list
+            except Exception as e:
+                if client.connected:
+                    await client.disconnect()
+                    await asyncio.sleep(0.1)
+                raise RuntimeError(
+                    f"Error during setup client and list tools: {e}"
+                ) from e
+
+        try:
+            try:
+                asyncio.get_running_loop()
+                import concurrent.futures
+
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(
+                        asyncio.run, _setup_client_and_list_tools()
+                    )
+                    tools_list = future.result()
+            except RuntimeError:
+                try:
+                    tools_list = asyncio.run(_setup_client_and_list_tools())
+                except RuntimeError as e:
+                    error_msg = str(e).lower()
+                    if "cancel scope" in error_msg or "task" in error_msg:
+                        raise ConnectionError(
+                            "MCP connection failed due to event loop cleanup issues. "
+                            "This may be due to authentication errors or server unavailability."
+                        ) from e
+                except asyncio.CancelledError as e:
+                    raise ConnectionError(
+                        "MCP connection was cancelled. This may indicate an authentication "
+                        "error or server unavailability."
+                    ) from e
+
+            if mcp_config.tool_filter:
+                filtered_tools = []
+                for tool in tools_list:
+                    if callable(mcp_config.tool_filter):
+                        try:
+                            from crewai.mcp.filters import ToolFilterContext
+
+                            context = ToolFilterContext(
+                                agent=self,
+                                server_name=server_name,
+                                run_context=None,
+                            )
+                            if mcp_config.tool_filter(context, tool):  # type: ignore[call-arg, arg-type]
+                                filtered_tools.append(tool)
+                        except (TypeError, AttributeError):
+                            if mcp_config.tool_filter(tool):  # type: ignore[call-arg, arg-type]
+                                filtered_tools.append(tool)
+                    else:
+                        # Not callable - include tool
+                        filtered_tools.append(tool)
+                tools_list = filtered_tools
+
+            tools = []
+            for tool_def in tools_list:
+                tool_name = tool_def.get("name", "")
+                if not tool_name:
+                    continue
+
+                # Convert inputSchema to Pydantic model if present
+                args_schema = None
+                if tool_def.get("inputSchema"):
+                    args_schema = self._json_schema_to_pydantic(
+                        tool_name, tool_def["inputSchema"]
+                    )
+
+                tool_schema = {
+                    "description": tool_def.get("description", ""),
+                    "args_schema": args_schema,
+                }
+
+                try:
+                    native_tool = MCPNativeTool(
+                        mcp_client=client,
+                        tool_name=tool_name,
+                        tool_schema=tool_schema,
+                        server_name=server_name,
+                    )
+                    tools.append(native_tool)
+                except Exception as e:
+                    self._logger.log("error", f"Failed to create native MCP tool: {e}")
+                    continue
+
+            return cast(list[BaseTool], tools), client
+        except Exception as e:
+            if client.connected:
+                asyncio.run(client.disconnect())
+
+            raise RuntimeError(f"Failed to get native MCP tools: {e}") from e
+
+    def _get_amp_mcp_tools(self, amp_ref: str) -> list[BaseTool]:
+        """Get tools from CrewAI AMP MCP marketplace."""
+        # Parse: "crewai-amp:mcp-name" or "crewai-amp:mcp-name#tool_name"
+        amp_part = amp_ref.replace("crewai-amp:", "")
+        if "#" in amp_part:
+            mcp_name, specific_tool = amp_part.split("#", 1)
+        else:
+            mcp_name, specific_tool = amp_part, None
+
+        # Call AMP API to get MCP server URLs
+        mcp_servers = self._fetch_amp_mcp_servers(mcp_name)
+
+        tools = []
+        for server_config in mcp_servers:
+            server_ref = server_config["url"]
+            if specific_tool:
+                server_ref += f"#{specific_tool}"
+            server_tools = self._get_external_mcp_tools(server_ref)
+            tools.extend(server_tools)
+
+        return tools
+
+    @staticmethod
+    def _extract_server_name(server_url: str) -> str:
+        """Extract clean server name from URL for tool prefixing."""
+
+        parsed = urlparse(server_url)
+        domain = parsed.netloc.replace(".", "_")
+        path = parsed.path.replace("/", "_").strip("_")
+        return f"{domain}_{path}" if path else domain
+
+    def _get_mcp_tool_schemas(
+        self, server_params: dict[str, Any]
+    ) -> dict[str, dict[str, Any]]:
+        """Get tool schemas from MCP server for wrapper creation with caching."""
+        server_url = server_params["url"]
+
+        # Check cache first
+        cache_key = server_url
+        current_time = time.time()
+
+        if cache_key in _mcp_schema_cache:
+            cached_data, cache_time = _mcp_schema_cache[cache_key]
+            if current_time - cache_time < _cache_ttl:
+                self._logger.log(
+                    "debug", f"Using cached MCP tool schemas for {server_url}"
+                )
+                return cached_data  # type: ignore[no-any-return]
+
+        try:
+            schemas = asyncio.run(self._get_mcp_tool_schemas_async(server_params))
+
+            # Cache successful results
+            _mcp_schema_cache[cache_key] = (schemas, current_time)
+
+            return schemas
+        except Exception as e:
+            # Log warning but don't raise - this allows graceful degradation
+            self._logger.log(
+                "warning", f"Failed to get MCP tool schemas from {server_url}: {e}"
+            )
+            return {}
+
+    async def _get_mcp_tool_schemas_async(
+        self, server_params: dict[str, Any]
+    ) -> dict[str, dict[str, Any]]:
+        """Async implementation of MCP tool schema retrieval with timeouts and retries."""
+        server_url = server_params["url"]
+        return await self._retry_mcp_discovery(
+            self._discover_mcp_tools_with_timeout, server_url
+        )
+
+    async def _retry_mcp_discovery(
+        self, operation_func: Any, server_url: str
+    ) -> dict[str, dict[str, Any]]:
+        """Retry MCP discovery operation with exponential backoff, avoiding try-except in loop."""
+        last_error = None
+
+        for attempt in range(MCP_MAX_RETRIES):
+            # Execute single attempt outside try-except loop structure
+            result, error, should_retry = await self._attempt_mcp_discovery(
+                operation_func, server_url
+            )
+
+            # Success case - return immediately
+            if result is not None:
+                return result
+
+            # Non-retryable error - raise immediately
+            if not should_retry:
+                raise RuntimeError(error)
+
+            # Retryable error - continue with backoff
+            last_error = error
+            if attempt < MCP_MAX_RETRIES - 1:
+                wait_time = 2**attempt  # Exponential backoff
+                await asyncio.sleep(wait_time)
+
+        raise RuntimeError(
+            f"Failed to discover MCP tools after {MCP_MAX_RETRIES} attempts: {last_error}"
+        )
+
+    @staticmethod
+    async def _attempt_mcp_discovery(
+        operation_func: Any, server_url: str
+    ) -> tuple[dict[str, dict[str, Any]] | None, str, bool]:
+        """Attempt single MCP discovery operation and return (result, error_message, should_retry)."""
+        try:
+            result = await operation_func(server_url)
+            return result, "", False
+
+        except ImportError:
+            return (
+                None,
+                "MCP library not available. Please install with: pip install mcp",
+                False,
+            )
+
+        except asyncio.TimeoutError:
+            return (
+                None,
+                f"MCP discovery timed out after {MCP_DISCOVERY_TIMEOUT} seconds",
+                True,
+            )
+
+        except Exception as e:
+            error_str = str(e).lower()
+
+            # Classify errors as retryable or non-retryable
+            if "authentication" in error_str or "unauthorized" in error_str:
+                return None, f"Authentication failed for MCP server: {e!s}", False
+            if "connection" in error_str or "network" in error_str:
+                return None, f"Network connection failed: {e!s}", True
+            if "json" in error_str or "parsing" in error_str:
+                return None, f"Server response parsing error: {e!s}", True
+            return None, f"MCP discovery error: {e!s}", False
+
+    async def _discover_mcp_tools_with_timeout(
+        self, server_url: str
+    ) -> dict[str, dict[str, Any]]:
+        """Discover MCP tools with timeout wrapper."""
+        return await asyncio.wait_for(
+            self._discover_mcp_tools(server_url), timeout=MCP_DISCOVERY_TIMEOUT
+        )
+
+    async def _discover_mcp_tools(self, server_url: str) -> dict[str, dict[str, Any]]:
+        """Discover tools from MCP server with proper timeout handling."""
+        from mcp import ClientSession
+        from mcp.client.streamable_http import streamablehttp_client
+
+        async with streamablehttp_client(server_url) as (read, write, _):
+            async with ClientSession(read, write) as session:
+                # Initialize the connection with timeout
+                await asyncio.wait_for(
+                    session.initialize(), timeout=MCP_CONNECTION_TIMEOUT
+                )
+
+                # List available tools with timeout
+                tools_result = await asyncio.wait_for(
+                    session.list_tools(),
+                    timeout=MCP_DISCOVERY_TIMEOUT - MCP_CONNECTION_TIMEOUT,
+                )
+
+                schemas = {}
+                for tool in tools_result.tools:
+                    args_schema = None
+                    if hasattr(tool, "inputSchema") and tool.inputSchema:
+                        args_schema = self._json_schema_to_pydantic(
+                            sanitize_tool_name(tool.name), tool.inputSchema
+                        )
+
+                    schemas[sanitize_tool_name(tool.name)] = {
+                        "description": getattr(tool, "description", ""),
+                        "args_schema": args_schema,
+                    }
+                return schemas
+
+    def _json_schema_to_pydantic(
+        self, tool_name: str, json_schema: dict[str, Any]
+    ) -> type:
+        """Convert JSON Schema to Pydantic model for tool arguments.
+
+        Args:
+            tool_name: Name of the tool (used for model naming)
+            json_schema: JSON Schema dict with 'properties', 'required', etc.
+
+        Returns:
+            Pydantic BaseModel class
+        """
+        from pydantic import Field, create_model
+
+        properties = json_schema.get("properties", {})
+        required_fields = json_schema.get("required", [])
+
+        field_definitions: dict[str, Any] = {}
+
+        for field_name, field_schema in properties.items():
+            field_type = self._json_type_to_python(field_schema)
+            field_description = field_schema.get("description", "")
+
+            is_required = field_name in required_fields
+
+            if is_required:
+                field_definitions[field_name] = (
+                    field_type,
+                    Field(..., description=field_description),
+                )
+            else:
+                field_definitions[field_name] = (
+                    field_type | None,
+                    Field(default=None, description=field_description),
+                )
+
+        model_name = f"{tool_name.replace('-', '_').replace(' ', '_')}Schema"
+        return create_model(model_name, **field_definitions)  # type: ignore[no-any-return]
+
+    def _json_type_to_python(self, field_schema: dict[str, Any]) -> type:
+        """Convert JSON Schema type to Python type.
+
+        Args:
+            field_schema: JSON Schema field definition
+
+        Returns:
+            Python type
+        """
+
+        json_type = field_schema.get("type")
+
+        if "anyOf" in field_schema:
+            types: list[type] = []
+            for option in field_schema["anyOf"]:
+                if "const" in option:
+                    types.append(str)
+                else:
+                    types.append(self._json_type_to_python(option))
+            unique_types = list(set(types))
+            if len(unique_types) > 1:
+                result: Any = unique_types[0]
+                for t in unique_types[1:]:
+                    result = result | t
+                return result  # type: ignore[no-any-return]
+            return unique_types[0]
+
+        type_mapping: dict[str | None, type] = {
+            "string": str,
+            "number": float,
+            "integer": int,
+            "boolean": bool,
+            "array": list,
+            "object": dict,
+        }
+
+        return type_mapping.get(json_type, Any)
+
+    @staticmethod
+    def _fetch_amp_mcp_servers(mcp_name: str) -> list[dict[str, Any]]:
+        """Fetch MCP server configurations from CrewAI AMP API."""
+        # TODO: Implement AMP API call to "integrations/mcps" endpoint
+        # Should return list of server configs with URLs
+        return []
 
     @staticmethod
     def get_multimodal_tools() -> Sequence[BaseTool]:
@@ -1165,19 +1712,6 @@ class Agent(BaseAgent):
 
         # Prepare tools
         raw_tools: list[BaseTool] = self.tools or []
-
-        # Inject memory tools for standalone kickoff (crew path handles its own)
-        agent_memory = getattr(self, "memory", None)
-        if agent_memory is not None:
-            from crewai.tools.memory_tools import create_memory_tools
-
-            existing_names = {sanitize_tool_name(t.name) for t in raw_tools}
-            raw_tools.extend(
-                mt
-                for mt in create_memory_tools(agent_memory)
-                if sanitize_tool_name(mt.name) not in existing_names
-            )
-
         parsed_tools = parse_tools(raw_tools)
 
         # Build agent_info for backward-compatible event emission
@@ -1252,49 +1786,6 @@ class Agent(BaseAgent):
         if input_files:
             all_files.update(input_files)
 
-        # Inject memory context for standalone kickoff (recall before execution)
-        if agent_memory is not None:
-            try:
-                crewai_event_bus.emit(
-                    self,
-                    event=MemoryRetrievalStartedEvent(
-                        task_id=None,
-                        source_type="agent_kickoff",
-                        from_agent=self,
-                    ),
-                )
-                start_time = time.time()
-                matches = agent_memory.recall(formatted_messages, limit=5)
-                memory_block = ""
-                if matches:
-                    memory_block = "Relevant memories:\n" + "\n".join(
-                        m.format() for m in matches
-                    )
-                if memory_block:
-                    formatted_messages += "\n\n" + self.i18n.slice("memory").format(
-                        memory=memory_block
-                    )
-                crewai_event_bus.emit(
-                    self,
-                    event=MemoryRetrievalCompletedEvent(
-                        task_id=None,
-                        memory_content=memory_block,
-                        retrieval_time_ms=(time.time() - start_time) * 1000,
-                        source_type="agent_kickoff",
-                        from_agent=self,
-                    ),
-                )
-            except Exception as e:
-                crewai_event_bus.emit(
-                    self,
-                    event=MemoryRetrievalFailedEvent(
-                        task_id=None,
-                        source_type="agent_kickoff",
-                        from_agent=self,
-                        error=str(e),
-                    ),
-                )
-
         # Build the input dict for the executor
         inputs: dict[str, Any] = {
             "input": formatted_messages,
@@ -1365,9 +1856,6 @@ class Agent(BaseAgent):
                     response_format=response_format,
                 )
 
-            # Save to memory after execution (passive save)
-            self._save_kickoff_to_memory(messages, output.raw)
-
             crewai_event_bus.emit(
                 self,
                 event=LiteAgentExecutionCompletedEvent(
@@ -1388,32 +1876,6 @@ class Agent(BaseAgent):
             )
             raise
 
-    def _save_kickoff_to_memory(
-        self, messages: str | list[LLMMessage], output_text: str
-    ) -> None:
-        """Save kickoff result to memory. No-op if agent has no memory."""
-        agent_memory = getattr(self, "memory", None)
-        if agent_memory is None:
-            return
-        try:
-            if isinstance(messages, str):
-                input_str = messages
-            else:
-                input_str = (
-                    "\n".join(
-                        str(msg.get("content", ""))
-                        for msg in messages
-                        if msg.get("content")
-                    )
-                    or "User request"
-                )
-            raw = f"Input: {input_str}\nAgent: {self.role}\nResult: {output_text}"
-            extracted = agent_memory.extract_memories(raw)
-            if extracted:
-                agent_memory.remember_many(extracted)
-        except Exception as e:
-            self._logger.log("error", f"Failed to save kickoff result to memory: {e}")
-
     def _execute_and_build_output(
         self,
         executor: AgentExecutor,
@@ -1696,9 +2158,6 @@ class Agent(BaseAgent):
                     response_format=response_format,
                 )
 
-            # Save to memory after async execution (passive save)
-            self._save_kickoff_to_memory(messages, output.raw)
-
             crewai_event_bus.emit(
                 self,
                 event=LiteAgentExecutionCompletedEvent(

lib/crewai/src/crewai/agents/agent_builder/base_agent.py

@@ -4,8 +4,7 @@ from abc import ABC, abstractmethod
 from collections.abc import Callable
 from copy import copy as shallow_copy
 from hashlib import md5
-import re
-from typing import Any, Final, Literal
+from typing import Any, Literal
 import uuid
 
 from pydantic import (
@@ -37,11 +36,6 @@ from crewai.utilities.rpm_controller import RPMController
 from crewai.utilities.string_utils import interpolate_only
 
 
-_SLUG_RE: Final[re.Pattern[str]] = re.compile(
-    r"^(?:crewai-amp:)?[a-zA-Z0-9][a-zA-Z0-9_-]*(?:#\w+)?$"
-)
-
-
 PlatformApp = Literal[
     "asana",
     "box",
@@ -203,15 +197,7 @@ class BaseAgent(BaseModel, ABC, metaclass=AgentMeta):
     )
     mcps: list[str | MCPServerConfig] | None = Field(
         default=None,
-        description="List of MCP server references. Supports 'https://server.com/path' for external servers and bare slugs like 'notion' for connected MCP integrations. Use '#tool_name' suffix for specific tools.",
-    )
-    memory: Any = Field(
-        default=None,
-        description=(
-            "Enable agent memory. Pass True for default Memory(), "
-            "or a Memory/MemoryScope/MemorySlice instance for custom configuration. "
-            "If not set, falls back to crew memory."
-        ),
+        description="List of MCP server references. Supports 'https://server.com/path' for external servers and 'crewai-amp:mcp-name' for AMP marketplace. Use '#tool_name' suffix for specific tools.",
     )
 
     @model_validator(mode="before")
@@ -282,16 +268,14 @@ class BaseAgent(BaseModel, ABC, metaclass=AgentMeta):
         validated_mcps: list[str | MCPServerConfig] = []
         for mcp in mcps:
             if isinstance(mcp, str):
-                if mcp.startswith("https://"):
-                    validated_mcps.append(mcp)
-                elif _SLUG_RE.match(mcp):
+                if mcp.startswith(("https://", "crewai-amp:")):
                     validated_mcps.append(mcp)
                 else:
                     raise ValueError(
-                        f"Invalid MCP reference: {mcp!r}. "
-                        "String references must be an 'https://' URL or a valid "
-                        "slug (e.g. 'notion', 'notion#search', 'crewai-amp:notion')."
+                        f"Invalid MCP reference: {mcp}. "
+                        "String references must start with 'https://' or 'crewai-amp:'"
                     )
+
             elif isinstance(mcp, (MCPServerConfig)):
                 validated_mcps.append(mcp)
             else:
@@ -345,17 +329,6 @@ class BaseAgent(BaseModel, ABC, metaclass=AgentMeta):
             self._token_process = TokenProcess()
         return self
 
-    @model_validator(mode="after")
-    def resolve_memory(self) -> Self:
-        """Resolve memory field: True creates a default Memory(), instance is used as-is."""
-        if self.memory is True:
-            from crewai.memory.unified_memory import Memory
-
-            self.memory = Memory()
-        elif self.memory is False:
-            self.memory = None
-        return self
-
     @property
     def key(self) -> str:
         source = [

lib/crewai/src/crewai/agents/agent_builder/base_agent_executor_mixin.py

@@ -1,8 +1,13 @@
 from __future__ import annotations
 
+import time
 from typing import TYPE_CHECKING
 
 from crewai.agents.parser import AgentFinish
+from crewai.memory.entity.entity_memory_item import EntityMemoryItem
+from crewai.memory.long_term.long_term_memory_item import LongTermMemoryItem
+from crewai.utilities.converter import ConverterError
+from crewai.utilities.evaluators.task_evaluator import TaskEvaluator
 from crewai.utilities.printer import Printer
 from crewai.utilities.string_utils import sanitize_tool_name
 
@@ -25,29 +30,110 @@ class CrewAgentExecutorMixin:
     _i18n: I18N
     _printer: Printer = Printer()
 
-    def _save_to_memory(self, output: AgentFinish) -> None:
-        """Save task result to unified memory (memory or crew._memory)."""
-        memory = getattr(self.agent, "memory", None) or (
-            getattr(self.crew, "_memory", None) if self.crew else None
-        )
-        if memory is None or not self.task or getattr(memory, "_read_only", False):
-            return
+    def _create_short_term_memory(self, output: AgentFinish) -> None:
+        """Create and save a short-term memory item if conditions are met."""
         if (
-            f"Action: {sanitize_tool_name('Delegate work to coworker')}"
-            in output.text
+            self.crew
+            and self.agent
+            and self.task
+            and f"Action: {sanitize_tool_name('Delegate work to coworker')}"
+            not in output.text
         ):
-            return
-        try:
-            raw = (
-                f"Task: {self.task.description}\n"
-                f"Agent: {self.agent.role}\n"
-                f"Expected result: {self.task.expected_output}\n"
-                f"Result: {output.text}"
-            )
-            extracted = memory.extract_memories(raw)
-            if extracted:
-                memory.remember_many(extracted, agent_role=self.agent.role)
-        except Exception as e:
-            self.agent._logger.log(
-                "error", f"Failed to save to memory: {e}"
-            )
+            try:
+                if (
+                    hasattr(self.crew, "_short_term_memory")
+                    and self.crew._short_term_memory
+                ):
+                    self.crew._short_term_memory.save(
+                        value=output.text,
+                        metadata={
+                            "observation": self.task.description,
+                        },
+                    )
+            except Exception as e:
+                self.agent._logger.log(
+                    "error", f"Failed to add to short term memory: {e}"
+                )
+
+    def _create_external_memory(self, output: AgentFinish) -> None:
+        """Create and save a external-term memory item if conditions are met."""
+        if (
+            self.crew
+            and self.agent
+            and self.task
+            and hasattr(self.crew, "_external_memory")
+            and self.crew._external_memory
+        ):
+            try:
+                self.crew._external_memory.save(
+                    value=output.text,
+                    metadata={
+                        "description": self.task.description,
+                        "messages": self.messages,
+                    },
+                )
+            except Exception as e:
+                self.agent._logger.log(
+                    "error", f"Failed to add to external memory: {e}"
+                )
+
+    def _create_long_term_memory(self, output: AgentFinish) -> None:
+        """Create and save long-term and entity memory items based on evaluation."""
+        if (
+            self.crew
+            and self.crew._long_term_memory
+            and self.crew._entity_memory
+            and self.task
+            and self.agent
+        ):
+            try:
+                ltm_agent = TaskEvaluator(self.agent)
+                evaluation = ltm_agent.evaluate(self.task, output.text)
+
+                if isinstance(evaluation, ConverterError):
+                    return
+
+                long_term_memory = LongTermMemoryItem(
+                    task=self.task.description,
+                    agent=self.agent.role,
+                    quality=evaluation.quality,
+                    datetime=str(time.time()),
+                    expected_output=self.task.expected_output,
+                    metadata={
+                        "suggestions": evaluation.suggestions,
+                        "quality": evaluation.quality,
+                    },
+                )
+                self.crew._long_term_memory.save(long_term_memory)
+
+                entity_memories = [
+                    EntityMemoryItem(
+                        name=entity.name,
+                        type=entity.type,
+                        description=entity.description,
+                        relationships="\n".join(
+                            [f"- {r}" for r in entity.relationships]
+                        ),
+                    )
+                    for entity in evaluation.entities
+                ]
+                if entity_memories:
+                    self.crew._entity_memory.save(entity_memories)
+            except AttributeError as e:
+                self.agent._logger.log(
+                    "error", f"Missing attributes for long term memory: {e}"
+                )
+            except Exception as e:
+                self.agent._logger.log(
+                    "error", f"Failed to add to long term memory: {e}"
+                )
+        elif (
+            self.crew
+            and self.crew._long_term_memory
+            and self.crew._entity_memory is None
+        ):
+            if self.agent and self.agent.verbose:
+                self._printer.print(
+                    content="Long term memory is enabled, but entity memory is not enabled. Please configure entity memory or set memory=True to automatically enable it.",
+                    color="bold_yellow",
+                )

lib/crewai/src/crewai/agents/crew_agent_executor.py

@@ -6,10 +6,7 @@ and memory management.
 
 from __future__ import annotations
 
-import asyncio
 from collections.abc import Callable
-from concurrent.futures import ThreadPoolExecutor, as_completed
-import inspect
 import logging
 from typing import TYPE_CHECKING, Any, Literal, cast
 
@@ -50,7 +47,6 @@ from crewai.utilities.agent_utils import (
     handle_unknown_error,
     has_reached_max_iterations,
     is_context_length_exceeded,
-    parse_tool_call_args,
     process_llm_response,
     track_delegation_if_needed,
 )
@@ -238,7 +234,9 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         if self.ask_for_human_input:
             formatted_answer = self._handle_human_feedback(formatted_answer)
 
-        self._save_to_memory(formatted_answer)
+        self._create_short_term_memory(formatted_answer)
+        self._create_long_term_memory(formatted_answer)
+        self._create_external_memory(formatted_answer)
         return {"output": formatted_answer.output}
 
     def _inject_multimodal_files(self, inputs: dict[str, Any] | None = None) -> None:
@@ -487,8 +485,8 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             # No tools available, fall back to simple LLM call
             return self._invoke_loop_native_no_tools()
 
-        openai_tools, available_functions, self._tool_name_mapping = (
-            convert_tools_to_openai_schema(self.original_tools)
+        openai_tools, available_functions = convert_tools_to_openai_schema(
+            self.original_tools
         )
 
         while True:
@@ -689,140 +687,30 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         Returns:
             AgentFinish if tool has result_as_answer=True, None otherwise.
         """
+        from datetime import datetime
+        import json
+
+        from crewai.events import crewai_event_bus
+        from crewai.events.types.tool_usage_events import (
+            ToolUsageErrorEvent,
+            ToolUsageFinishedEvent,
+            ToolUsageStartedEvent,
+        )
+
         if not tool_calls:
             return None
 
-        parsed_calls = [
-            parsed
-            for tool_call in tool_calls
-            if (parsed := self._parse_native_tool_call(tool_call)) is not None
-        ]
-        if not parsed_calls:
-            return None
+        # Only process the FIRST tool call for sequential execution with reflection
+        tool_call = tool_calls[0]
 
-        original_tools_by_name: dict[str, Any] = dict(self._tool_name_mapping)
-
-        if len(parsed_calls) > 1:
-            has_result_as_answer_in_batch = any(
-                bool(
-                    original_tools_by_name.get(func_name)
-                    and getattr(
-                        original_tools_by_name.get(func_name), "result_as_answer", False
-                    )
-                )
-                for _, func_name, _ in parsed_calls
-            )
-            has_max_usage_count_in_batch = any(
-                bool(
-                    original_tools_by_name.get(func_name)
-                    and getattr(
-                        original_tools_by_name.get(func_name),
-                        "max_usage_count",
-                        None,
-                    )
-                    is not None
-                )
-                for _, func_name, _ in parsed_calls
-            )
-
-            # Preserve historical sequential behavior for result_as_answer batches.
-            # Also avoid threading around usage counters for max_usage_count tools.
-            if has_result_as_answer_in_batch or has_max_usage_count_in_batch:
-                logger.debug(
-                    "Skipping parallel native execution because batch includes result_as_answer or max_usage_count tool"
-                )
-            else:
-                execution_plan: list[
-                    tuple[str, str, str | dict[str, Any], Any | None]
-                ] = []
-                for call_id, func_name, func_args in parsed_calls:
-                    original_tool = original_tools_by_name.get(func_name)
-                    execution_plan.append(
-                        (call_id, func_name, func_args, original_tool)
-                    )
-
-                self._append_assistant_tool_calls_message(
-                    [
-                        (call_id, func_name, func_args)
-                        for call_id, func_name, func_args, _ in execution_plan
-                    ]
-                )
-
-                max_workers = min(8, len(execution_plan))
-                ordered_results: list[dict[str, Any] | None] = [None] * len(
-                    execution_plan
-                )
-                with ThreadPoolExecutor(max_workers=max_workers) as pool:
-                    futures = {
-                        pool.submit(
-                            self._execute_single_native_tool_call,
-                            call_id=call_id,
-                            func_name=func_name,
-                            func_args=func_args,
-                            available_functions=available_functions,
-                            original_tool=original_tool,
-                            should_execute=True,
-                        ): idx
-                        for idx, (
-                            call_id,
-                            func_name,
-                            func_args,
-                            original_tool,
-                        ) in enumerate(execution_plan)
-                    }
-                    for future in as_completed(futures):
-                        idx = futures[future]
-                        ordered_results[idx] = future.result()
-
-                for execution_result in ordered_results:
-                    if not execution_result:
-                        continue
-                    tool_finish = self._append_tool_result_and_check_finality(
-                        execution_result
-                    )
-                    if tool_finish:
-                        return tool_finish
-
-                reasoning_prompt = self._i18n.slice("post_tool_reasoning")
-                reasoning_message: LLMMessage = {
-                    "role": "user",
-                    "content": reasoning_prompt,
-                }
-                self.messages.append(reasoning_message)
-                return None
-
-        # Sequential behavior: process only first tool call, then force reflection.
-        call_id, func_name, func_args = parsed_calls[0]
-        self._append_assistant_tool_calls_message([(call_id, func_name, func_args)])
-
-        execution_result = self._execute_single_native_tool_call(
-            call_id=call_id,
-            func_name=func_name,
-            func_args=func_args,
-            available_functions=available_functions,
-            original_tool=original_tools_by_name.get(func_name),
-            should_execute=True,
-        )
-        tool_finish = self._append_tool_result_and_check_finality(execution_result)
-        if tool_finish:
-            return tool_finish
-
-        reasoning_prompt = self._i18n.slice("post_tool_reasoning")
-        reasoning_message = {
-            "role": "user",
-            "content": reasoning_prompt,
-        }
-        self.messages.append(reasoning_message)
-        return None
-
-    def _parse_native_tool_call(
-        self, tool_call: Any
-    ) -> tuple[str, str, str | dict[str, Any]] | None:
+        # Extract tool call info - handle OpenAI-style, Anthropic-style, and Gemini-style
         if hasattr(tool_call, "function"):
+            # OpenAI-style: has .function.name and .function.arguments
             call_id = getattr(tool_call, "id", f"call_{id(tool_call)}")
             func_name = sanitize_tool_name(tool_call.function.name)
-            return call_id, func_name, tool_call.function.arguments
-        if hasattr(tool_call, "function_call") and tool_call.function_call:
+            func_args = tool_call.function.arguments
+        elif hasattr(tool_call, "function_call") and tool_call.function_call:
+            # Gemini-style: has .function_call.name and .function_call.args
             call_id = f"call_{id(tool_call)}"
             func_name = sanitize_tool_name(tool_call.function_call.name)
             func_args = (
@@ -830,12 +718,13 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                 if tool_call.function_call.args
                 else {}
             )
-            return call_id, func_name, func_args
-        if hasattr(tool_call, "name") and hasattr(tool_call, "input"):
+        elif hasattr(tool_call, "name") and hasattr(tool_call, "input"):
+            # Anthropic format: has .name and .input (ToolUseBlock)
             call_id = getattr(tool_call, "id", f"call_{id(tool_call)}")
             func_name = sanitize_tool_name(tool_call.name)
-            return call_id, func_name, tool_call.input
-        if isinstance(tool_call, dict):
+            func_args = tool_call.input  # Already a dict in Anthropic
+        elif isinstance(tool_call, dict):
+            # Support OpenAI "id", Bedrock "toolUseId", or generate one
             call_id = (
                 tool_call.get("id")
                 or tool_call.get("toolUseId")
@@ -846,15 +735,10 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                 func_info.get("name", "") or tool_call.get("name", "")
             )
             func_args = func_info.get("arguments", "{}") or tool_call.get("input", {})
-            return call_id, func_name, func_args
-        return None
-
-    def _append_assistant_tool_calls_message(
-        self,
-        parsed_calls: list[tuple[str, str, str | dict[str, Any]]],
-    ) -> None:
-        import json
+        else:
+            return None
 
+        # Append assistant message with single tool call
         assistant_message: LLMMessage = {
             "role": "assistant",
             "content": None,
@@ -869,54 +753,42 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         else json.dumps(func_args),
                     },
                 }
-                for call_id, func_name, func_args in parsed_calls
             ],
         }
+
         self.messages.append(assistant_message)
 
-    def _execute_single_native_tool_call(
-        self,
-        *,
-        call_id: str,
-        func_name: str,
-        func_args: str | dict[str, Any],
-        available_functions: dict[str, Callable[..., Any]],
-        original_tool: Any | None = None,
-        should_execute: bool = True,
-    ) -> dict[str, Any]:
-        from datetime import datetime
-        import json
+        # Parse arguments for the single tool call
+        if isinstance(func_args, str):
+            try:
+                args_dict = json.loads(func_args)
+            except json.JSONDecodeError:
+                args_dict = {}
+        else:
+            args_dict = func_args
 
-        from crewai.events.types.tool_usage_events import (
-            ToolUsageErrorEvent,
-            ToolUsageFinishedEvent,
-            ToolUsageStartedEvent,
-        )
+        agent_key = getattr(self.agent, "key", "unknown") if self.agent else "unknown"
 
-        args_dict, parse_error = parse_tool_call_args(func_args, func_name, call_id, original_tool)
-        if parse_error is not None:
-            return parse_error
+        # Find original tool by matching sanitized name (needed for cache_function and result_as_answer)
 
-        if original_tool is None:
-            for tool in self.original_tools or []:
-                if sanitize_tool_name(tool.name) == func_name:
-                    original_tool = tool
-                    break
+        original_tool = None
+        for tool in self.original_tools or []:
+            if sanitize_tool_name(tool.name) == func_name:
+                original_tool = tool
+                break
 
+        # Check if tool has reached max usage count
         max_usage_reached = False
-        if not should_execute and original_tool:
-            max_usage_reached = True
-        elif (
-            should_execute
-            and original_tool
-            and (max_count := getattr(original_tool, "max_usage_count", None))
-            is not None
-            and getattr(original_tool, "current_usage_count", 0) >= max_count
-        ):
-            max_usage_reached = True
+        if original_tool:
+            if (
+                hasattr(original_tool, "max_usage_count")
+                and original_tool.max_usage_count is not None
+                and original_tool.current_usage_count >= original_tool.max_usage_count
+            ):
+                max_usage_reached = True
 
+        # Check cache before executing
         from_cache = False
-        result: str = "Tool not found"
         input_str = json.dumps(args_dict) if args_dict else ""
         if self.tools_handler and self.tools_handler.cache:
             cached_result = self.tools_handler.cache.read(
@@ -930,7 +802,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                 )
                 from_cache = True
 
-        agent_key = getattr(self.agent, "key", "unknown") if self.agent else "unknown"
+        # Emit tool usage started event
         started_at = datetime.now()
         crewai_event_bus.emit(
             self,
@@ -946,18 +818,14 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
 
         track_delegation_if_needed(func_name, args_dict, self.task)
 
+        # Find the structured tool for hook context
         structured_tool: CrewStructuredTool | None = None
-        if original_tool is not None:
-            for structured in self.tools or []:
-                if getattr(structured, "_original_tool", None) is original_tool:
-                    structured_tool = structured
-                    break
-        if structured_tool is None:
-            for structured in self.tools or []:
-                if sanitize_tool_name(structured.name) == func_name:
-                    structured_tool = structured
-                    break
+        for structured in self.tools or []:
+            if sanitize_tool_name(structured.name) == func_name:
+                structured_tool = structured
+                break
 
+        # Execute before_tool_call hooks
         hook_blocked = False
         before_hook_context = ToolCallHookContext(
             tool_name=func_name,
@@ -981,48 +849,58 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     color="red",
                 )
 
+        # If hook blocked execution, set result and skip tool execution
         if hook_blocked:
             result = f"Tool execution blocked by hook. Tool: {func_name}"
+        # Execute the tool (only if not cached, not at max usage, and not blocked by hook)
+        elif not from_cache and not max_usage_reached:
+            result = "Tool not found"
+            if func_name in available_functions:
+                try:
+                    tool_func = available_functions[func_name]
+                    raw_result = tool_func(**args_dict)
+
+                    # Add to cache after successful execution (before string conversion)
+                    if self.tools_handler and self.tools_handler.cache:
+                        should_cache = True
+                        if (
+                            original_tool
+                            and hasattr(original_tool, "cache_function")
+                            and callable(original_tool.cache_function)
+                        ):
+                            should_cache = original_tool.cache_function(
+                                args_dict, raw_result
+                            )
+                        if should_cache:
+                            self.tools_handler.cache.add(
+                                tool=func_name, input=input_str, output=raw_result
+                            )
+
+                    # Convert to string for message
+                    result = (
+                        str(raw_result)
+                        if not isinstance(raw_result, str)
+                        else raw_result
+                    )
+                except Exception as e:
+                    result = f"Error executing tool: {e}"
+                    if self.task:
+                        self.task.increment_tools_errors()
+                    crewai_event_bus.emit(
+                        self,
+                        event=ToolUsageErrorEvent(
+                            tool_name=func_name,
+                            tool_args=args_dict,
+                            from_agent=self.agent,
+                            from_task=self.task,
+                            agent_key=agent_key,
+                            error=e,
+                        ),
+                    )
+                    error_event_emitted = True
         elif max_usage_reached and original_tool:
+            # Return error message when max usage limit is reached
             result = f"Tool '{func_name}' has reached its usage limit of {original_tool.max_usage_count} times and cannot be used anymore."
-        elif not from_cache and func_name in available_functions:
-            try:
-                raw_result = available_functions[func_name](**args_dict)
-
-                if self.tools_handler and self.tools_handler.cache:
-                    should_cache = True
-                    if (
-                        original_tool
-                        and hasattr(original_tool, "cache_function")
-                        and callable(original_tool.cache_function)
-                    ):
-                        should_cache = original_tool.cache_function(
-                            args_dict, raw_result
-                        )
-                    if should_cache:
-                        self.tools_handler.cache.add(
-                            tool=func_name, input=input_str, output=raw_result
-                        )
-
-                result = (
-                    str(raw_result) if not isinstance(raw_result, str) else raw_result
-                )
-            except Exception as e:
-                result = f"Error executing tool: {e}"
-                if self.task:
-                    self.task.increment_tools_errors()
-                crewai_event_bus.emit(
-                    self,
-                    event=ToolUsageErrorEvent(
-                        tool_name=func_name,
-                        tool_args=args_dict,
-                        from_agent=self.agent,
-                        from_task=self.task,
-                        agent_key=agent_key,
-                        error=e,
-                    ),
-                )
-                error_event_emitted = True
 
         after_hook_context = ToolCallHookContext(
             tool_name=func_name,
@@ -1062,23 +940,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                 ),
             )
 
-        return {
-            "call_id": call_id,
-            "func_name": func_name,
-            "result": result,
-            "from_cache": from_cache,
-            "original_tool": original_tool,
-        }
-
-    def _append_tool_result_and_check_finality(
-        self, execution_result: dict[str, Any]
-    ) -> AgentFinish | None:
-        call_id = cast(str, execution_result["call_id"])
-        func_name = cast(str, execution_result["func_name"])
-        result = cast(str, execution_result["result"])
-        from_cache = cast(bool, execution_result["from_cache"])
-        original_tool = execution_result["original_tool"]
-
+        # Append tool result message
         tool_message: LLMMessage = {
             "role": "tool",
             "tool_call_id": call_id,
@@ -1087,6 +949,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         }
         self.messages.append(tool_message)
 
+        # Log the tool execution
         if self.agent and self.agent.verbose:
             cache_info = " (from cache)" if from_cache else ""
             self._printer.print(
@@ -1099,11 +962,20 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             and hasattr(original_tool, "result_as_answer")
             and original_tool.result_as_answer
         ):
+            # Return immediately with tool result as final answer
             return AgentFinish(
                 thought="Tool result is the final answer",
                 output=result,
                 text=result,
             )
+
+        # Inject post-tool reasoning prompt to enforce analysis
+        reasoning_prompt = self._i18n.slice("post_tool_reasoning")
+        reasoning_message: LLMMessage = {
+            "role": "user",
+            "content": reasoning_prompt,
+        }
+        self.messages.append(reasoning_message)
         return None
 
     async def ainvoke(self, inputs: dict[str, Any]) -> dict[str, Any]:
@@ -1139,7 +1011,9 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         if self.ask_for_human_input:
             formatted_answer = await self._ahandle_human_feedback(formatted_answer)
 
-        self._save_to_memory(formatted_answer)
+        self._create_short_term_memory(formatted_answer)
+        self._create_long_term_memory(formatted_answer)
+        self._create_external_memory(formatted_answer)
         return {"output": formatted_answer.output}
 
     async def _ainvoke_loop(self) -> AgentFinish:
@@ -1263,7 +1137,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         formatted_answer, tool_result
                     )
 
-                await self._ainvoke_step_callback(formatted_answer)  # type: ignore[arg-type]
+                self._invoke_step_callback(formatted_answer)  # type: ignore[arg-type]
                 self._append_message(formatted_answer.text)  # type: ignore[union-attr]
 
             except OutputParserError as e:
@@ -1316,8 +1190,8 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         if not self.original_tools:
             return await self._ainvoke_loop_native_no_tools()
 
-        openai_tools, available_functions, self._tool_name_mapping = (
-            convert_tools_to_openai_schema(self.original_tools)
+        openai_tools, available_functions = convert_tools_to_openai_schema(
+            self.original_tools
         )
 
         while True:
@@ -1378,7 +1252,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         output=answer,
                         text=answer,
                     )
-                    await self._ainvoke_step_callback(formatted_answer)
+                    self._invoke_step_callback(formatted_answer)
                     self._append_message(answer)  # Save final answer to messages
                     self._show_logs(formatted_answer)
                     return formatted_answer
@@ -1390,7 +1264,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         output=answer,
                         text=output_json,
                     )
-                    await self._ainvoke_step_callback(formatted_answer)
+                    self._invoke_step_callback(formatted_answer)
                     self._append_message(output_json)
                     self._show_logs(formatted_answer)
                     return formatted_answer
@@ -1401,7 +1275,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     output=str(answer),
                     text=str(answer),
                 )
-                await self._ainvoke_step_callback(formatted_answer)
+                self._invoke_step_callback(formatted_answer)
                 self._append_message(str(answer))  # Save final answer to messages
                 self._show_logs(formatted_answer)
                 return formatted_answer
@@ -1495,28 +1369,13 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
     def _invoke_step_callback(
         self, formatted_answer: AgentAction | AgentFinish
     ) -> None:
-        """Invoke step callback (sync context).
+        """Invoke step callback.
 
         Args:
             formatted_answer: Current agent response.
         """
         if self.step_callback:
-            cb_result = self.step_callback(formatted_answer)
-            if inspect.iscoroutine(cb_result):
-                asyncio.run(cb_result)
-
-    async def _ainvoke_step_callback(
-        self, formatted_answer: AgentAction | AgentFinish
-    ) -> None:
-        """Invoke step callback (async context).
-
-        Args:
-            formatted_answer: Current agent response.
-        """
-        if self.step_callback:
-            cb_result = self.step_callback(formatted_answer)
-            if inspect.iscoroutine(cb_result):
-                await cb_result
+            self.step_callback(formatted_answer)
 
     def _append_message(
         self, text: str, role: Literal["user", "assistant", "system"] = "assistant"

lib/crewai/src/crewai/cli/authentication/main.py

@@ -2,8 +2,8 @@ import time
 from typing import TYPE_CHECKING, Any, TypeVar, cast
 import webbrowser
 
-import httpx
 from pydantic import BaseModel, Field
+import requests
 from rich.console import Console
 
 from crewai.cli.authentication.utils import validate_jwt_token
@@ -98,7 +98,7 @@ class AuthenticationCommand:
             "scope": " ".join(self.oauth2_provider.get_oauth_scopes()),
             "audience": self.oauth2_provider.get_audience(),
         }
-        response = httpx.post(
+        response = requests.post(
             url=self.oauth2_provider.get_authorize_url(),
             data=device_code_payload,
             timeout=20,
@@ -130,7 +130,7 @@ class AuthenticationCommand:
 
         attempts = 0
         while True and attempts < 10:
-            response = httpx.post(
+            response = requests.post(
                 self.oauth2_provider.get_token_url(), data=token_payload, timeout=30
             )
             token_data = response.json()
@@ -149,7 +149,7 @@ class AuthenticationCommand:
                 return
 
             if token_data["error"] not in ("authorization_pending", "slow_down"):
-                raise httpx.HTTPError(
+                raise requests.HTTPError(
                     token_data.get("error_description") or token_data.get("error")
                 )
 

lib/crewai/src/crewai/cli/cli.py

@@ -1,7 +1,6 @@
 from importlib.metadata import version as get_version
 import os
 import subprocess
-from typing import Any
 
 import click
 
@@ -180,19 +179,9 @@ def log_tasks_outputs() -> None:
 
 
 @crewai.command()
-@click.option("-m", "--memory", is_flag=True, help="Reset MEMORY")
-@click.option(
-    "-l", "--long", is_flag=True, hidden=True,
-    help="[Deprecated: use --memory] Reset memory",
-)
-@click.option(
-    "-s", "--short", is_flag=True, hidden=True,
-    help="[Deprecated: use --memory] Reset memory",
-)
-@click.option(
-    "-e", "--entities", is_flag=True, hidden=True,
-    help="[Deprecated: use --memory] Reset memory",
-)
+@click.option("-l", "--long", is_flag=True, help="Reset LONG TERM memory")
+@click.option("-s", "--short", is_flag=True, help="Reset SHORT TERM memory")
+@click.option("-e", "--entities", is_flag=True, help="Reset ENTITIES memory")
 @click.option("-kn", "--knowledge", is_flag=True, help="Reset KNOWLEDGE storage")
 @click.option(
     "-akn", "--agent-knowledge", is_flag=True, help="Reset AGENT KNOWLEDGE storage"
@@ -202,7 +191,6 @@ def log_tasks_outputs() -> None:
 )
 @click.option("-a", "--all", is_flag=True, help="Reset ALL memories")
 def reset_memories(
-    memory: bool,
     long: bool,
     short: bool,
     entities: bool,
@@ -212,22 +200,13 @@ def reset_memories(
     all: bool,
 ) -> None:
     """
-    Reset the crew memories (memory, knowledge, agent_knowledge, kickoff_outputs). This will delete all the data saved.
+    Reset the crew memories (long, short, entity, latest_crew_kickoff_ouputs, knowledge, agent_knowledge). This will delete all the data saved.
     """
     try:
-        # Treat legacy flags as --memory with a deprecation warning
-        if long or short or entities:
-            legacy_used = [
-                f for f, v in [("--long", long), ("--short", short), ("--entities", entities)] if v
-            ]
-            click.echo(
-                f"Warning: {', '.join(legacy_used)} {'is' if len(legacy_used) == 1 else 'are'} "
-                "deprecated. Use --memory (-m) instead. All memory is now unified."
-            )
-            memory = True
-
         memory_types = [
-            memory,
+            long,
+            short,
+            entities,
             knowledge,
             agent_knowledge,
             kickoff_outputs,
@@ -239,73 +218,12 @@ def reset_memories(
             )
             return
         reset_memories_command(
-            memory, knowledge, agent_knowledge, kickoff_outputs, all
+            long, short, entities, knowledge, agent_knowledge, kickoff_outputs, all
         )
     except Exception as e:
         click.echo(f"An error occurred while resetting memories: {e}", err=True)
 
 
-@crewai.command()
-@click.option(
-    "--storage-path",
-    type=str,
-    default=None,
-    help="Path to LanceDB memory directory. If omitted, uses ./.crewai/memory.",
-)
-@click.option(
-    "--embedder-provider",
-    type=str,
-    default=None,
-    help="Embedder provider for recall queries (e.g. openai, google-vertex, cohere, ollama).",
-)
-@click.option(
-    "--embedder-model",
-    type=str,
-    default=None,
-    help="Embedder model name (e.g. text-embedding-3-small, gemini-embedding-001).",
-)
-@click.option(
-    "--embedder-config",
-    type=str,
-    default=None,
-    help='Full embedder config as JSON (e.g. \'{"provider": "cohere", "config": {"model_name": "embed-v4.0"}}\').',
-)
-def memory(
-    storage_path: str | None,
-    embedder_provider: str | None,
-    embedder_model: str | None,
-    embedder_config: str | None,
-) -> None:
-    """Open the Memory TUI to browse scopes and recall memories."""
-    try:
-        from crewai.cli.memory_tui import MemoryTUI
-    except ImportError as exc:
-        click.echo(
-            "Textual is required for the memory TUI but could not be imported. "
-            "Try reinstalling crewai or: pip install textual"
-        )
-        raise SystemExit(1) from exc
-
-    # Build embedder spec from CLI flags.
-    embedder_spec: dict[str, Any] | None = None
-    if embedder_config:
-        import json as _json
-
-        try:
-            embedder_spec = _json.loads(embedder_config)
-        except _json.JSONDecodeError as exc:
-            click.echo(f"Invalid --embedder-config JSON: {exc}")
-            raise SystemExit(1) from exc
-    elif embedder_provider:
-        cfg: dict[str, str] = {}
-        if embedder_model:
-            cfg["model_name"] = embedder_model
-        embedder_spec = {"provider": embedder_provider, "config": cfg}
-
-    app = MemoryTUI(storage_path=storage_path, embedder_config=embedder_spec)
-    app.run()
-
-
 @crewai.command()
 @click.option(
     "-n",

lib/crewai/src/crewai/cli/command.py

@@ -1,6 +1,5 @@
-import json
-
-import httpx
+import requests
+from requests.exceptions import JSONDecodeError
 from rich.console import Console
 
 from crewai.cli.authentication.token import get_auth_token
@@ -31,16 +30,16 @@ class PlusAPIMixin:
             console.print("Run 'crewai login' to sign up/login.", style="bold green")
             raise SystemExit from None
 
-    def _validate_response(self, response: httpx.Response) -> None:
+    def _validate_response(self, response: requests.Response) -> None:
         """
         Handle and display error messages from API responses.
 
         Args:
-            response (httpx.Response): The response from the Plus API
+            response (requests.Response): The response from the Plus API
         """
         try:
             json_response = response.json()
-        except (json.JSONDecodeError, ValueError):
+        except (JSONDecodeError, ValueError):
             console.print(
                 "Failed to parse response from Enterprise API failed. Details:",
                 style="bold red",
@@ -63,7 +62,7 @@ class PlusAPIMixin:
                     )
             raise SystemExit
 
-        if not response.is_success:
+        if not response.ok:
             console.print(
                 "Request to Enterprise API failed. Details:", style="bold red"
             )

lib/crewai/src/crewai/cli/constants.py

@@ -69,7 +69,7 @@ ENV_VARS: dict[str, list[dict[str, Any]]] = {
         },
         {
             "prompt": "Enter your AWS Region Name (press Enter to skip)",
-            "key_name": "AWS_DEFAULT_REGION",
+            "key_name": "AWS_REGION_NAME",
         },
     ],
     "azure": [

lib/crewai/src/crewai/cli/enterprise/main.py

@@ -1,7 +1,7 @@
-import json
 from typing import Any, cast
 
-import httpx
+import requests
+from requests.exceptions import JSONDecodeError, RequestException
 from rich.console import Console
 
 from crewai.cli.authentication.main import Oauth2Settings, ProviderFactory
@@ -47,12 +47,12 @@ class EnterpriseConfigureCommand(BaseCommand):
                 "User-Agent": f"CrewAI-CLI/{get_crewai_version()}",
                 "X-Crewai-Version": get_crewai_version(),
             }
-            response = httpx.get(oauth_endpoint, timeout=30, headers=headers)
+            response = requests.get(oauth_endpoint, timeout=30, headers=headers)
             response.raise_for_status()
 
             try:
                 oauth_config = response.json()
-            except json.JSONDecodeError as e:
+            except JSONDecodeError as e:
                 raise ValueError(f"Invalid JSON response from {oauth_endpoint}") from e
 
             self._validate_oauth_config(oauth_config)
@@ -62,7 +62,7 @@ class EnterpriseConfigureCommand(BaseCommand):
             )
             return cast(dict[str, Any], oauth_config)
 
-        except httpx.HTTPError as e:
+        except RequestException as e:
             raise ValueError(f"Failed to connect to enterprise URL: {e!s}") from e
         except Exception as e:
             raise ValueError(f"Error fetching OAuth2 configuration: {e!s}") from e

lib/crewai/src/crewai/cli/memory_tui.py

@@ -1,410 +0,0 @@
-"""Textual TUI for browsing and recalling unified memory."""
-
-from __future__ import annotations
-
-import asyncio
-from typing import Any
-
-from textual.app import App, ComposeResult
-from textual.containers import Horizontal, Vertical
-from textual.widgets import Footer, Header, Input, OptionList, Static, Tree
-
-
-# -- CrewAI brand palette --
-_PRIMARY = "#eb6658"  # coral
-_SECONDARY = "#1F7982"  # teal
-_TERTIARY = "#ffffff"  # white
-
-
-def _format_scope_info(info: Any) -> str:
-    """Format ScopeInfo with Rich markup."""
-    return (
-        f"[bold {_PRIMARY}]{info.path}[/]\n\n"
-        f"[dim]Records:[/]     [bold]{info.record_count}[/]\n"
-        f"[dim]Categories:[/]  {', '.join(info.categories) or 'none'}\n"
-        f"[dim]Oldest:[/]      {info.oldest_record or '-'}\n"
-        f"[dim]Newest:[/]      {info.newest_record or '-'}\n"
-        f"[dim]Children:[/]    {', '.join(info.child_scopes) or 'none'}"
-    )
-
-
-class MemoryTUI(App[None]):
-    """TUI to browse memory scopes and run recall queries."""
-
-    TITLE = "CrewAI Memory"
-    SUB_TITLE = "Browse scopes and recall memories"
-
-    CSS = f"""
-    Header {{
-        background: {_PRIMARY};
-        color: {_TERTIARY};
-    }}
-    Footer {{
-        background: {_SECONDARY};
-        color: {_TERTIARY};
-    }}
-    Footer > .footer-key--key {{
-        background: {_PRIMARY};
-        color: {_TERTIARY};
-    }}
-    Horizontal {{
-        height: 1fr;
-    }}
-    #scope-tree {{
-        width: 30%;
-        padding: 1 2;
-        background: {_SECONDARY} 8%;
-        border-right: solid {_SECONDARY};
-    }}
-    #scope-tree:focus > .tree--cursor {{
-        background: {_SECONDARY};
-        color: {_TERTIARY};
-    }}
-    #scope-tree > .tree--guides {{
-        color: {_SECONDARY} 50%;
-    }}
-    #scope-tree > .tree--guides-hover {{
-        color: {_PRIMARY};
-    }}
-    #scope-tree > .tree--guides-selected {{
-        color: {_SECONDARY};
-    }}
-    #right-panel {{
-        width: 70%;
-        padding: 0 1;
-    }}
-    #info-panel {{
-        height: 2fr;
-        padding: 1 2;
-        overflow-y: auto;
-        border: round {_SECONDARY};
-    }}
-    #info-panel:focus {{
-        border: round {_PRIMARY};
-    }}
-    #info-panel LoadingIndicator {{
-        color: {_PRIMARY};
-    }}
-    #entry-list {{
-        height: 1fr;
-        border: round {_SECONDARY};
-        padding: 0 1;
-        scrollbar-color: {_PRIMARY};
-    }}
-    #entry-list:focus {{
-        border: round {_PRIMARY};
-    }}
-    #entry-list > .option-list--option-highlighted {{
-        background: {_SECONDARY};
-        color: {_TERTIARY};
-    }}
-    #recall-input {{
-        margin: 0 1 1 1;
-        border: tall {_SECONDARY};
-    }}
-    #recall-input:focus {{
-        border: tall {_PRIMARY};
-    }}
-    """
-
-    def __init__(
-        self,
-        storage_path: str | None = None,
-        embedder_config: dict[str, Any] | None = None,
-    ) -> None:
-        super().__init__()
-        self._memory: Any = None
-        self._init_error: str | None = None
-        self._selected_scope: str = "/"
-        self._entries: list[Any] = []
-        self._view_mode: str = "list"  # "list" | "recall"
-        self._recall_matches: list[Any] = []
-        self._last_scope_info: Any = None
-        self._custom_embedder = embedder_config is not None
-        try:
-            from crewai.memory.storage.lancedb_storage import LanceDBStorage
-            from crewai.memory.unified_memory import Memory
-
-            storage = LanceDBStorage(path=storage_path) if storage_path else LanceDBStorage()
-            embedder = None
-            if embedder_config is not None:
-                from crewai.rag.embeddings.factory import build_embedder
-
-                embedder = build_embedder(embedder_config)
-            self._memory = Memory(storage=storage, embedder=embedder) if embedder else Memory(storage=storage)
-        except Exception as e:
-            self._init_error = str(e)
-
-    def compose(self) -> ComposeResult:
-        yield Header(show_clock=False)
-        with Horizontal():
-            yield self._build_scope_tree()
-            initial = (
-                self._init_error
-                if self._init_error
-                else "Select a scope or type a recall query."
-            )
-            with Vertical(id="right-panel"):
-                yield Static(initial, id="info-panel")
-                yield OptionList(id="entry-list")
-        yield Input(
-            placeholder="Type a query and press Enter to recall...",
-            id="recall-input",
-        )
-        yield Footer()
-
-    def on_mount(self) -> None:
-        """Set initial border titles on mounted widgets."""
-        self.query_one("#info-panel", Static).border_title = "Detail"
-        self.query_one("#entry-list", OptionList).border_title = "Entries"
-
-    def _build_scope_tree(self) -> Tree[str]:
-        tree: Tree[str] = Tree("/", id="scope-tree")
-        if self._memory is None:
-            tree.root.data = "/"
-            tree.root.label = "/ (0 records)"
-            return tree
-        info = self._memory.info("/")
-        tree.root.label = f"/ ({info.record_count} records)"
-        tree.root.data = "/"
-        self._add_children(tree.root, "/", depth=0, max_depth=3)
-        tree.root.expand()
-        return tree
-
-    def _add_children(
-        self,
-        parent_node: Tree.Node[str],
-        path: str,
-        depth: int,
-        max_depth: int,
-    ) -> None:
-        if depth >= max_depth or self._memory is None:
-            return
-        info = self._memory.info(path)
-        for child in info.child_scopes:
-            child_info = self._memory.info(child)
-            label = f"{child} ({child_info.record_count})"
-            node = parent_node.add(label, data=child)
-            self._add_children(node, child, depth + 1, max_depth)
-
-    # -- Populating the OptionList -------------------------------------------
-
-    def _populate_entry_list(self) -> None:
-        """Clear the OptionList and fill it with the current scope's entries."""
-        option_list = self.query_one("#entry-list", OptionList)
-        option_list.clear_options()
-        for record in self._entries:
-            date_str = record.created_at.strftime("%Y-%m-%d")
-            preview = (
-                (record.content[:80] + "…")
-                if len(record.content) > 80
-                else record.content
-            )
-            label = (
-                f"{date_str}  "
-                f"[bold]{record.importance:.1f}[/]  "
-                f"{preview}"
-            )
-            option_list.add_option(label)
-
-    def _populate_recall_list(self) -> None:
-        """Clear the OptionList and fill it with the current recall matches."""
-        option_list = self.query_one("#entry-list", OptionList)
-        option_list.clear_options()
-        if not self._recall_matches:
-            return
-        for m in self._recall_matches:
-            preview = (
-                (m.record.content[:80] + "…")
-                if len(m.record.content) > 80
-                else m.record.content
-            )
-            label = (
-                f"[bold]\\[{m.score:.2f}][/]  "
-                f"{preview}  "
-                f"[dim]scope={m.record.scope}[/]"
-            )
-            option_list.add_option(label)
-
-    # -- Detail rendering ----------------------------------------------------
-
-    def _format_record_detail(self, record: Any, context_line: str = "") -> str:
-        """Format a full MemoryRecord as Rich markup for the detail view.
-
-        Args:
-            record: A MemoryRecord instance.
-            context_line: Optional header line shown above the fields
-                (e.g. "Entry 3 of 47").
-
-        Returns:
-            A Rich-markup string with all meaningful record fields.
-        """
-        sep = f"[bold {_PRIMARY}]{'─' * 44}[/]"
-        lines: list[str] = []
-
-        if context_line:
-            lines.append(context_line)
-            lines.append("")
-
-        # -- Fields block --
-        lines.append(f"[dim]ID:[/]             {record.id}")
-        lines.append(f"[dim]Scope:[/]          [bold]{record.scope}[/]")
-        lines.append(f"[dim]Importance:[/]      [bold]{record.importance:.2f}[/]")
-        lines.append(
-            f"[dim]Created:[/]        "
-            f"{record.created_at.strftime('%Y-%m-%d %H:%M:%S')}"
-        )
-        lines.append(
-            f"[dim]Last accessed:[/]  "
-            f"{record.last_accessed.strftime('%Y-%m-%d %H:%M:%S')}"
-        )
-        lines.append(
-            f"[dim]Categories:[/]     "
-            f"{', '.join(record.categories) if record.categories else 'none'}"
-        )
-        lines.append(f"[dim]Source:[/]         {record.source or '-'}")
-        lines.append(f"[dim]Private:[/]        {'Yes' if record.private else 'No'}")
-
-        # -- Content block --
-        lines.append(f"\n{sep}")
-        lines.append("[bold]Content[/]\n")
-        lines.append(record.content)
-
-        # -- Metadata block --
-        if record.metadata:
-            lines.append(f"\n{sep}")
-            lines.append("[bold]Metadata[/]\n")
-            for k, v in record.metadata.items():
-                lines.append(f"[dim]{k}:[/] {v}")
-
-        return "\n".join(lines)
-
-    # -- Event handlers ------------------------------------------------------
-
-    def on_tree_node_selected(self, event: Tree.NodeSelected[str]) -> None:
-        """Load entries for the selected scope and populate the OptionList."""
-        path = event.node.data if event.node.data is not None else "/"
-        self._selected_scope = path
-        self._view_mode = "list"
-        panel = self.query_one("#info-panel", Static)
-        if self._memory is None:
-            panel.update(self._init_error or "No memory loaded.")
-            return
-        display_limit = 1000
-        info = self._memory.info(path)
-        self._last_scope_info = info
-        self._entries = self._memory.list_records(scope=path, limit=display_limit)
-        panel.update(_format_scope_info(info))
-        panel.border_title = "Detail"
-        entry_list = self.query_one("#entry-list", OptionList)
-        capped = info.record_count > display_limit
-        count_label = (
-            f"Entries (showing {display_limit} of {info.record_count} — display limit)"
-            if capped
-            else f"Entries ({len(self._entries)})"
-        )
-        entry_list.border_title = count_label
-        self._populate_entry_list()
-
-    def on_option_list_option_highlighted(
-        self, event: OptionList.OptionHighlighted
-    ) -> None:
-        """Live-update the info panel with the detail of the highlighted entry."""
-        panel = self.query_one("#info-panel", Static)
-        idx = event.option_index
-
-        if self._view_mode == "list":
-            if idx < len(self._entries):
-                record = self._entries[idx]
-                total = len(self._entries)
-                context = (
-                    f"[bold {_PRIMARY}]Entry {idx + 1} of {total}[/]  "
-                    f"[dim]in[/] [bold]{self._selected_scope}[/]"
-                )
-                panel.border_title = f"Entry {idx + 1} of {total}"
-                panel.update(self._format_record_detail(record, context_line=context))
-
-        elif self._view_mode == "recall":
-            if idx < len(self._recall_matches):
-                match = self._recall_matches[idx]
-                total = len(self._recall_matches)
-                panel.border_title = f"Match {idx + 1} of {total}"
-                score_color = _PRIMARY if match.score >= 0.5 else "dim"
-                header_lines: list[str] = [
-                    f"[bold {_PRIMARY}]Recall Match {idx + 1} of {total}[/]\n",
-                    f"[dim]Score:[/]          [{score_color}][bold]{match.score:.2f}[/][/]",
-                    (
-                        f"[dim]Match reasons:[/]  "
-                        f"{', '.join(match.match_reasons) if match.match_reasons else '-'}"
-                    ),
-                    (
-                        f"[dim]Evidence gaps:[/]  "
-                        f"{', '.join(match.evidence_gaps) if match.evidence_gaps else 'none'}"
-                    ),
-                    f"\n[bold {_PRIMARY}]{'─' * 44}[/]",
-                ]
-                record_detail = self._format_record_detail(match.record)
-                header_lines.append(record_detail)
-                panel.update("\n".join(header_lines))
-
-    def on_input_submitted(self, event: Input.Submitted) -> None:
-        query = event.value.strip()
-        if not query:
-            return
-        if self._memory is None:
-            panel = self.query_one("#info-panel", Static)
-            panel.update(self._init_error or "No memory loaded. Cannot recall.")
-            return
-        self.run_worker(self._do_recall(query), exclusive=True)
-
-    async def _do_recall(self, query: str) -> None:
-        """Execute a recall query and display results in the OptionList."""
-        panel = self.query_one("#info-panel", Static)
-        panel.loading = True
-        try:
-            scope = (
-                self._selected_scope
-                if self._selected_scope != "/"
-                else None
-            )
-            loop = asyncio.get_event_loop()
-            matches = await loop.run_in_executor(
-                None,
-                lambda: self._memory.recall(
-                    query, scope=scope, limit=10, depth="deep"
-                ),
-            )
-            self._recall_matches = matches or []
-            self._view_mode = "recall"
-
-            if not self._recall_matches:
-                panel.update("[dim]No memories found.[/]")
-                self.query_one("#entry-list", OptionList).clear_options()
-                return
-
-            info_lines: list[str] = []
-            info_lines.append(
-                "[dim italic]Searched the full dataset"
-                + (f" within [bold]{scope}[/]" if scope else "")
-                + " using the recall flow (semantic + recency + importance).[/]\n"
-            )
-            if not self._custom_embedder:
-                info_lines.append(
-                    "[dim italic]Note: Using default OpenAI embedder. "
-                    "If memories were created with a different embedder, "
-                    "pass --embedder-provider to match.[/]\n"
-                )
-            info_lines.append(
-                f"[bold]Recall Results[/] [dim]"
-                f"({len(self._recall_matches)} matches)[/]\n"
-                f"[dim]Navigate the list below to view details.[/]"
-            )
-            panel.update("\n".join(info_lines))
-            panel.border_title = "Recall Detail"
-            entry_list = self.query_one("#entry-list", OptionList)
-            entry_list.border_title = f"Recall Results ({len(self._recall_matches)})"
-            self._populate_recall_list()
-        except Exception as e:
-            panel.update(f"[bold red]Error:[/] {e}")
-        finally:
-            panel.loading = False

lib/crewai/src/crewai/cli/organization/main.py

@@ -1,4 +1,4 @@
-from httpx import HTTPStatusError
+from requests import HTTPError
 from rich.console import Console
 from rich.table import Table
 
@@ -10,11 +10,11 @@ console = Console()
 
 
 class OrganizationCommand(BaseCommand, PlusAPIMixin):
-    def __init__(self) -> None:
+    def __init__(self):
         BaseCommand.__init__(self)
         PlusAPIMixin.__init__(self, telemetry=self._telemetry)
 
-    def list(self) -> None:
+    def list(self):
         try:
             response = self.plus_api_client.get_organizations()
             response.raise_for_status()
@@ -33,7 +33,7 @@ class OrganizationCommand(BaseCommand, PlusAPIMixin):
                 table.add_row(org["name"], org["uuid"])
 
             console.print(table)
-        except HTTPStatusError as e:
+        except HTTPError as e:
             if e.response.status_code == 401:
                 console.print(
                     "You are not logged in to any organization. Use 'crewai login' to login.",
@@ -50,7 +50,7 @@ class OrganizationCommand(BaseCommand, PlusAPIMixin):
             )
             raise SystemExit(1) from e
 
-    def switch(self, org_id: str) -> None:
+    def switch(self, org_id):
         try:
             response = self.plus_api_client.get_organizations()
             response.raise_for_status()
@@ -72,7 +72,7 @@ class OrganizationCommand(BaseCommand, PlusAPIMixin):
                 f"Successfully switched to {org['name']} ({org['uuid']})",
                 style="bold green",
             )
-        except HTTPStatusError as e:
+        except HTTPError as e:
             if e.response.status_code == 401:
                 console.print(
                     "You are not logged in to any organization. Use 'crewai login' to login.",
@@ -87,7 +87,7 @@ class OrganizationCommand(BaseCommand, PlusAPIMixin):
             console.print(f"Failed to switch organization: {e!s}", style="bold red")
             raise SystemExit(1) from e
 
-    def current(self) -> None:
+    def current(self):
         settings = Settings()
         if settings.org_uuid:
             console.print(

lib/crewai/src/crewai/cli/plus_api.py

@@ -3,6 +3,7 @@ from typing import Any
 from urllib.parse import urljoin
 
 import httpx
+import requests
 
 from crewai.cli.config import Settings
 from crewai.cli.constants import DEFAULT_CREWAI_ENTERPRISE_URL
@@ -42,16 +43,16 @@ class PlusAPI:
 
     def _make_request(
         self, method: str, endpoint: str, **kwargs: Any
-    ) -> httpx.Response:
+    ) -> requests.Response:
         url = urljoin(self.base_url, endpoint)
-        verify = kwargs.pop("verify", True)
-        with httpx.Client(trust_env=False, verify=verify) as client:
-            return client.request(method, url, headers=self.headers, **kwargs)
+        session = requests.Session()
+        session.trust_env = False
+        return session.request(method, url, headers=self.headers, **kwargs)
 
-    def login_to_tool_repository(self) -> httpx.Response:
+    def login_to_tool_repository(self) -> requests.Response:
         return self._make_request("POST", f"{self.TOOLS_RESOURCE}/login")
 
-    def get_tool(self, handle: str) -> httpx.Response:
+    def get_tool(self, handle: str) -> requests.Response:
         return self._make_request("GET", f"{self.TOOLS_RESOURCE}/{handle}")
 
     async def get_agent(self, handle: str) -> httpx.Response:
@@ -67,7 +68,7 @@ class PlusAPI:
         description: str | None,
         encoded_file: str,
         available_exports: list[dict[str, Any]] | None = None,
-    ) -> httpx.Response:
+    ) -> requests.Response:
         params = {
             "handle": handle,
             "public": is_public,
@@ -78,52 +79,54 @@ class PlusAPI:
         }
         return self._make_request("POST", f"{self.TOOLS_RESOURCE}", json=params)
 
-    def deploy_by_name(self, project_name: str) -> httpx.Response:
+    def deploy_by_name(self, project_name: str) -> requests.Response:
         return self._make_request(
             "POST", f"{self.CREWS_RESOURCE}/by-name/{project_name}/deploy"
         )
 
-    def deploy_by_uuid(self, uuid: str) -> httpx.Response:
+    def deploy_by_uuid(self, uuid: str) -> requests.Response:
         return self._make_request("POST", f"{self.CREWS_RESOURCE}/{uuid}/deploy")
 
-    def crew_status_by_name(self, project_name: str) -> httpx.Response:
+    def crew_status_by_name(self, project_name: str) -> requests.Response:
         return self._make_request(
             "GET", f"{self.CREWS_RESOURCE}/by-name/{project_name}/status"
         )
 
-    def crew_status_by_uuid(self, uuid: str) -> httpx.Response:
+    def crew_status_by_uuid(self, uuid: str) -> requests.Response:
         return self._make_request("GET", f"{self.CREWS_RESOURCE}/{uuid}/status")
 
     def crew_by_name(
         self, project_name: str, log_type: str = "deployment"
-    ) -> httpx.Response:
+    ) -> requests.Response:
         return self._make_request(
             "GET", f"{self.CREWS_RESOURCE}/by-name/{project_name}/logs/{log_type}"
         )
 
-    def crew_by_uuid(self, uuid: str, log_type: str = "deployment") -> httpx.Response:
+    def crew_by_uuid(
+        self, uuid: str, log_type: str = "deployment"
+    ) -> requests.Response:
         return self._make_request(
             "GET", f"{self.CREWS_RESOURCE}/{uuid}/logs/{log_type}"
         )
 
-    def delete_crew_by_name(self, project_name: str) -> httpx.Response:
+    def delete_crew_by_name(self, project_name: str) -> requests.Response:
         return self._make_request(
             "DELETE", f"{self.CREWS_RESOURCE}/by-name/{project_name}"
         )
 
-    def delete_crew_by_uuid(self, uuid: str) -> httpx.Response:
+    def delete_crew_by_uuid(self, uuid: str) -> requests.Response:
         return self._make_request("DELETE", f"{self.CREWS_RESOURCE}/{uuid}")
 
-    def list_crews(self) -> httpx.Response:
+    def list_crews(self) -> requests.Response:
         return self._make_request("GET", self.CREWS_RESOURCE)
 
-    def create_crew(self, payload: dict[str, Any]) -> httpx.Response:
+    def create_crew(self, payload: dict[str, Any]) -> requests.Response:
         return self._make_request("POST", self.CREWS_RESOURCE, json=payload)
 
-    def get_organizations(self) -> httpx.Response:
+    def get_organizations(self) -> requests.Response:
         return self._make_request("GET", self.ORGANIZATIONS_RESOURCE)
 
-    def initialize_trace_batch(self, payload: dict[str, Any]) -> httpx.Response:
+    def initialize_trace_batch(self, payload: dict[str, Any]) -> requests.Response:
         return self._make_request(
             "POST",
             f"{self.TRACING_RESOURCE}/batches",
@@ -133,7 +136,7 @@ class PlusAPI:
 
     def initialize_ephemeral_trace_batch(
         self, payload: dict[str, Any]
-    ) -> httpx.Response:
+    ) -> requests.Response:
         return self._make_request(
             "POST",
             f"{self.EPHEMERAL_TRACING_RESOURCE}/batches",
@@ -142,7 +145,7 @@ class PlusAPI:
 
     def send_trace_events(
         self, trace_batch_id: str, payload: dict[str, Any]
-    ) -> httpx.Response:
+    ) -> requests.Response:
         return self._make_request(
             "POST",
             f"{self.TRACING_RESOURCE}/batches/{trace_batch_id}/events",
@@ -152,7 +155,7 @@ class PlusAPI:
 
     def send_ephemeral_trace_events(
         self, trace_batch_id: str, payload: dict[str, Any]
-    ) -> httpx.Response:
+    ) -> requests.Response:
         return self._make_request(
             "POST",
             f"{self.EPHEMERAL_TRACING_RESOURCE}/batches/{trace_batch_id}/events",
@@ -162,7 +165,7 @@ class PlusAPI:
 
     def finalize_trace_batch(
         self, trace_batch_id: str, payload: dict[str, Any]
-    ) -> httpx.Response:
+    ) -> requests.Response:
         return self._make_request(
             "PATCH",
             f"{self.TRACING_RESOURCE}/batches/{trace_batch_id}/finalize",
@@ -172,7 +175,7 @@ class PlusAPI:
 
     def finalize_ephemeral_trace_batch(
         self, trace_batch_id: str, payload: dict[str, Any]
-    ) -> httpx.Response:
+    ) -> requests.Response:
         return self._make_request(
             "PATCH",
             f"{self.EPHEMERAL_TRACING_RESOURCE}/batches/{trace_batch_id}/finalize",
@@ -182,7 +185,7 @@ class PlusAPI:
 
     def mark_trace_batch_as_failed(
         self, trace_batch_id: str, error_message: str
-    ) -> httpx.Response:
+    ) -> requests.Response:
         return self._make_request(
             "PATCH",
             f"{self.TRACING_RESOURCE}/batches/{trace_batch_id}",
@@ -190,20 +193,13 @@ class PlusAPI:
             timeout=30,
         )
 
-    def get_mcp_configs(self, slugs: list[str]) -> httpx.Response:
-        """Get MCP server configurations for the given slugs."""
-        return self._make_request(
-            "GET",
-            f"{self.INTEGRATIONS_RESOURCE}/mcp_configs",
-            params={"slugs": ",".join(slugs)},
-            timeout=30,
-        )
-
-    def get_triggers(self) -> httpx.Response:
+    def get_triggers(self) -> requests.Response:
         """Get all available triggers from integrations."""
         return self._make_request("GET", f"{self.INTEGRATIONS_RESOURCE}/apps")
 
-    def get_trigger_payload(self, app_slug: str, trigger_slug: str) -> httpx.Response:
+    def get_trigger_payload(
+        self, app_slug: str, trigger_slug: str
+    ) -> requests.Response:
         """Get sample payload for a specific trigger."""
         return self._make_request(
             "GET", f"{self.INTEGRATIONS_RESOURCE}/{app_slug}/{trigger_slug}/payload"

lib/crewai/src/crewai/cli/provider.py

@@ -8,7 +8,7 @@ from typing import Any
 
 import certifi
 import click
-import httpx
+import requests
 
 from crewai.cli.constants import JSON_URL, MODELS, PROVIDERS
 
@@ -165,20 +165,20 @@ def fetch_provider_data(cache_file: Path) -> dict[str, Any] | None:
     ssl_config = os.environ["SSL_CERT_FILE"] = certifi.where()
 
     try:
-        with httpx.stream("GET", JSON_URL, timeout=60, verify=ssl_config) as response:
-            response.raise_for_status()
-            data = download_data(response)
-            with open(cache_file, "w") as f:
-                json.dump(data, f)
-            return data
-    except httpx.HTTPError as e:
+        response = requests.get(JSON_URL, stream=True, timeout=60, verify=ssl_config)
+        response.raise_for_status()
+        data = download_data(response)
+        with open(cache_file, "w") as f:
+            json.dump(data, f)
+        return data
+    except requests.RequestException as e:
         click.secho(f"Error fetching provider data: {e}", fg="red")
     except json.JSONDecodeError:
         click.secho("Error parsing provider data. Invalid JSON format.", fg="red")
     return None
 
 
-def download_data(response: httpx.Response) -> dict[str, Any]:
+def download_data(response: requests.Response) -> dict[str, Any]:
     """Downloads data from a given HTTP response and returns the JSON content.
 
     Args:
@@ -194,7 +194,7 @@ def download_data(response: httpx.Response) -> dict[str, Any]:
     with click.progressbar(
         length=total_size, label="Downloading", show_pos=True
     ) as bar:
-        for chunk in response.iter_bytes(block_size):
+        for chunk in response.iter_content(block_size):
             if chunk:
                 data_chunks.append(chunk)
                 bar.update(len(chunk))

lib/crewai/src/crewai/cli/reset_memories_command.py

@@ -2,61 +2,43 @@ import subprocess
 
 import click
 
-from crewai.cli.utils import get_crews, get_flows
-from crewai.flow import Flow
-
-
-def _reset_flow_memory(flow: Flow) -> None:
-    """Reset memory for a single flow instance.
-
-    Handles Memory, MemoryScope (both have .reset()), and MemorySlice
-    (delegates to the underlying ._memory).  Silently succeeds when the
-    storage directory does not exist yet (nothing to reset).
-
-    Args:
-        flow: The flow instance whose memory should be reset.
-    """
-    mem = flow.memory
-    if mem is None:
-        return
-    try:
-        if hasattr(mem, "reset"):
-            mem.reset()
-        elif hasattr(mem, "_memory") and hasattr(mem._memory, "reset"):
-            mem._memory.reset()
-    except (FileNotFoundError, OSError):
-        pass
+from crewai.cli.utils import get_crews
 
 
 def reset_memories_command(
-    memory: bool,
-    knowledge: bool,
-    agent_knowledge: bool,
-    kickoff_outputs: bool,
-    all: bool,
+    long,
+    short,
+    entity,
+    knowledge,
+    agent_knowledge,
+    kickoff_outputs,
+    all,
 ) -> None:
-    """Reset the crew and flow memories.
+    """
+    Reset the crew memories.
 
     Args:
-        memory: Whether to reset the unified memory.
-        knowledge: Whether to reset the knowledge.
-        agent_knowledge: Whether to reset the agents knowledge.
-        kickoff_outputs: Whether to reset the latest kickoff task outputs.
-        all: Whether to reset all memories.
+      long (bool): Whether to reset the long-term memory.
+      short (bool): Whether to reset the short-term memory.
+      entity (bool): Whether to reset the entity memory.
+      kickoff_outputs (bool): Whether to reset the latest kickoff task outputs.
+      all (bool): Whether to reset all memories.
+      knowledge (bool): Whether to reset the knowledge.
+      agent_knowledge (bool): Whether to reset the agents knowledge.
     """
+
     try:
-        if not any([memory, kickoff_outputs, knowledge, agent_knowledge, all]):
+        if not any(
+            [long, short, entity, kickoff_outputs, knowledge, agent_knowledge, all]
+        ):
             click.echo(
                 "No memory type specified. Please specify at least one type to reset."
             )
             return
 
         crews = get_crews()
-        flows = get_flows()
-
-        if not crews and not flows:
-            raise ValueError("No crew or flow found.")
-
+        if not crews:
+            raise ValueError("No crew found.")
         for crew in crews:
             if all:
                 crew.reset_memories(command_type="all")
@@ -64,10 +46,20 @@ def reset_memories_command(
                     f"[Crew ({crew.name if crew.name else crew.id})] Reset memories command has been completed."
                 )
                 continue
-            if memory:
-                crew.reset_memories(command_type="memory")
+            if long:
+                crew.reset_memories(command_type="long")
                 click.echo(
-                    f"[Crew ({crew.name if crew.name else crew.id})] Memory has been reset."
+                    f"[Crew ({crew.name if crew.name else crew.id})] Long term memory has been reset."
+                )
+            if short:
+                crew.reset_memories(command_type="short")
+                click.echo(
+                    f"[Crew ({crew.name if crew.name else crew.id})] Short term memory has been reset."
+                )
+            if entity:
+                crew.reset_memories(command_type="entity")
+                click.echo(
+                    f"[Crew ({crew.name if crew.name else crew.id})] Entity memory has been reset."
                 )
             if kickoff_outputs:
                 crew.reset_memories(command_type="kickoff_outputs")
@@ -85,20 +77,6 @@ def reset_memories_command(
                     f"[Crew ({crew.name if crew.name else crew.id})] Agents knowledge has been reset."
                 )
 
-        for flow in flows:
-            flow_name = flow.name or flow.__class__.__name__
-            if all:
-                _reset_flow_memory(flow)
-                click.echo(
-                    f"[Flow ({flow_name})] Reset memories command has been completed."
-                )
-                continue
-            if memory:
-                _reset_flow_memory(flow)
-                click.echo(
-                    f"[Flow ({flow_name})] Memory has been reset."
-                )
-
     except subprocess.CalledProcessError as e:
         click.echo(f"An error occurred while resetting the memories: {e}", err=True)
         click.echo(e.output, err=True)

lib/crewai/src/crewai/cli/templates/crew/crew.py

@@ -1,6 +1,7 @@
 from crewai import Agent, Crew, Process, Task
 from crewai.project import CrewBase, agent, crew, task
 from crewai.agents.agent_builder.base_agent import BaseAgent
+from typing import List
 # If you want to run a snippet of code before or after the crew starts,
 # you can use the @before_kickoff and @after_kickoff decorators
 # https://docs.crewai.com/concepts/crews#example-crew-class-with-decorators
@@ -9,8 +10,8 @@ from crewai.agents.agent_builder.base_agent import BaseAgent
 class {{crew_name}}():
     """{{crew_name}} crew"""
 
-    agents: list[BaseAgent]
-    tasks: list[Task]
+    agents: List[BaseAgent]
+    tasks: List[Task]
 
     # Learn more about YAML configuration files here:
     # Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended

lib/crewai/src/crewai/cli/templates/crew/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]==1.10.1a1"
+    "crewai[tools]==1.9.3"
 ]
 
 [project.scripts]

lib/crewai/src/crewai/cli/templates/flow/crews/poem_crew/poem_crew.py

@@ -1,3 +1,5 @@
+from typing import List
+
 from crewai import Agent, Crew, Process, Task
 from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.project import CrewBase, agent, crew, task
@@ -11,8 +13,8 @@ from crewai.project import CrewBase, agent, crew, task
 class PoemCrew:
     """Poem Crew"""
 
-    agents: list[BaseAgent]
-    tasks: list[Task]
+    agents: List[BaseAgent]
+    tasks: List[Task]
 
     # Learn more about YAML configuration files here:
     # Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended

lib/crewai/src/crewai/cli/templates/flow/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]==1.10.1a1"
+    "crewai[tools]==1.9.3"
 ]
 
 [project.scripts]

lib/crewai/src/crewai/cli/templates/tool/pyproject.toml

@@ -5,7 +5,7 @@ description = "Power up your crews with {{folder_name}}"
 readme = "README.md"
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]==1.10.1a1"
+    "crewai[tools]>=0.203.1"
 ]
 
 [tool.crewai]

lib/crewai/src/crewai/cli/utils.py

@@ -386,109 +386,6 @@ def fetch_crews(module_attr: Any) -> list[Crew]:
     return crew_instances
 
 
-def get_flow_instance(module_attr: Any) -> Flow | None:
-    """Check if a module attribute is a user-defined Flow subclass and return an instance.
-
-    Args:
-        module_attr: An attribute from a loaded module.
-
-    Returns:
-        A Flow instance if the attribute is a valid user-defined Flow subclass,
-        None otherwise.
-    """
-    if (
-        isinstance(module_attr, type)
-        and issubclass(module_attr, Flow)
-        and module_attr is not Flow
-    ):
-        try:
-            return module_attr()
-        except Exception:
-            return None
-    return None
-
-
-_SKIP_DIRS = frozenset(
-    {".venv", "venv", ".git", "__pycache__", "node_modules", ".tox", ".nox"}
-)
-
-
-def get_flows(flow_path: str = "main.py") -> list[Flow]:
-    """Get the flow instances from project files.
-
-    Walks the project directory looking for files matching ``flow_path``
-    (default ``main.py``), loads each module, and extracts Flow subclass
-    instances.  Directories that are clearly not user source code (virtual
-    environments, ``.git``, etc.) are pruned to avoid noisy import errors.
-
-    Args:
-        flow_path: Filename to search for (default ``main.py``).
-
-    Returns:
-        A list of discovered Flow instances.
-    """
-    flow_instances: list[Flow] = []
-    try:
-        current_dir = os.getcwd()
-        if current_dir not in sys.path:
-            sys.path.insert(0, current_dir)
-
-        src_dir = os.path.join(current_dir, "src")
-        if os.path.isdir(src_dir) and src_dir not in sys.path:
-            sys.path.insert(0, src_dir)
-
-        search_paths = [".", "src"] if os.path.isdir("src") else ["."]
-
-        for search_path in search_paths:
-            for root, dirs, files in os.walk(search_path):
-                dirs[:] = [
-                    d
-                    for d in dirs
-                    if d not in _SKIP_DIRS and not d.startswith(".")
-                ]
-                if flow_path in files and "cli/templates" not in root:
-                    file_os_path = os.path.join(root, flow_path)
-                    try:
-                        spec = importlib.util.spec_from_file_location(
-                            "flow_module", file_os_path
-                        )
-                        if not spec or not spec.loader:
-                            continue
-
-                        module = importlib.util.module_from_spec(spec)
-                        sys.modules[spec.name] = module
-
-                        try:
-                            spec.loader.exec_module(module)
-
-                            for attr_name in dir(module):
-                                module_attr = getattr(module, attr_name)
-                                try:
-                                    if flow_instance := get_flow_instance(
-                                        module_attr
-                                    ):
-                                        flow_instances.append(flow_instance)
-                                except Exception:  # noqa: S112
-                                    continue
-
-                            if flow_instances:
-                                break
-
-                        except Exception:  # noqa: S112
-                            continue
-
-                    except (ImportError, AttributeError):
-                        continue
-
-            if flow_instances:
-                break
-
-    except Exception:  # noqa: S110
-        pass
-
-    return flow_instances
-
-
 def is_valid_tool(obj: Any) -> bool:
     from crewai.tools.base_tool import Tool
 

lib/crewai/src/crewai/crew.py

@@ -83,6 +83,10 @@ from crewai.knowledge.knowledge import Knowledge
 from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
 from crewai.llm import LLM
 from crewai.llms.base_llm import BaseLLM
+from crewai.memory.entity.entity_memory import EntityMemory
+from crewai.memory.external.external_memory import ExternalMemory
+from crewai.memory.long_term.long_term_memory import LongTermMemory
+from crewai.memory.short_term.short_term_memory import ShortTermMemory
 from crewai.process import Process
 from crewai.rag.embeddings.types import EmbedderConfig
 from crewai.rag.types import SearchResult
@@ -170,7 +174,10 @@ class Crew(FlowTrackable, BaseModel):
     _logger: Logger = PrivateAttr()
     _file_handler: FileHandler = PrivateAttr()
     _cache_handler: InstanceOf[CacheHandler] = PrivateAttr(default_factory=CacheHandler)
-    _memory: Any = PrivateAttr(default=None)  # Unified Memory | MemoryScope
+    _short_term_memory: InstanceOf[ShortTermMemory] | None = PrivateAttr()
+    _long_term_memory: InstanceOf[LongTermMemory] | None = PrivateAttr()
+    _entity_memory: InstanceOf[EntityMemory] | None = PrivateAttr()
+    _external_memory: InstanceOf[ExternalMemory] | None = PrivateAttr()
     _train: bool | None = PrivateAttr(default=False)
     _train_iteration: int | None = PrivateAttr()
     _inputs: dict[str, Any] | None = PrivateAttr(default=None)
@@ -188,12 +195,25 @@ class Crew(FlowTrackable, BaseModel):
     agents: list[BaseAgent] = Field(default_factory=list)
     process: Process = Field(default=Process.sequential)
     verbose: bool = Field(default=False)
-    memory: bool | Any = Field(
+    memory: bool = Field(
         default=False,
-        description=(
-            "Enable crew memory. Pass True for default Memory(), "
-            "or a Memory/MemoryScope/MemorySlice instance for custom configuration."
-        ),
+        description="If crew should use memory to store memories of it's execution",
+    )
+    short_term_memory: InstanceOf[ShortTermMemory] | None = Field(
+        default=None,
+        description="An Instance of the ShortTermMemory to be used by the Crew",
+    )
+    long_term_memory: InstanceOf[LongTermMemory] | None = Field(
+        default=None,
+        description="An Instance of the LongTermMemory to be used by the Crew",
+    )
+    entity_memory: InstanceOf[EntityMemory] | None = Field(
+        default=None,
+        description="An Instance of the EntityMemory to be used by the Crew",
+    )
+    external_memory: InstanceOf[ExternalMemory] | None = Field(
+        default=None,
+        description="An Instance of the ExternalMemory to be used by the Crew",
     )
     embedder: EmbedderConfig | None = Field(
         default=None,
@@ -352,23 +372,31 @@ class Crew(FlowTrackable, BaseModel):
 
         return self
 
+    def _initialize_default_memories(self) -> None:
+        self._long_term_memory = self._long_term_memory or LongTermMemory()
+        self._short_term_memory = self._short_term_memory or ShortTermMemory(
+            crew=self,
+            embedder_config=self.embedder,
+        )
+        self._entity_memory = self.entity_memory or EntityMemory(
+            crew=self, embedder_config=self.embedder
+        )
+
     @model_validator(mode="after")
     def create_crew_memory(self) -> Crew:
-        """Initialize unified memory, respecting crew embedder config."""
-        if self.memory is True:
-            from crewai.memory.unified_memory import Memory
+        """Initialize private memory attributes."""
+        self._external_memory = (
+            # External memory does not support a default value since it was
+            # designed to be managed entirely externally
+            self.external_memory.set_crew(self) if self.external_memory else None
+        )
 
-            embedder = None
-            if self.embedder is not None:
-                from crewai.rag.embeddings.factory import build_embedder
+        self._long_term_memory = self.long_term_memory
+        self._short_term_memory = self.short_term_memory
+        self._entity_memory = self.entity_memory
 
-                embedder = build_embedder(self.embedder)
-            self._memory = Memory(embedder=embedder)
-        elif self.memory:
-            # User passed a Memory / MemoryScope / MemorySlice instance
-            self._memory = self.memory
-        else:
-            self._memory = None
+        if self.memory:
+            self._initialize_default_memories()
 
         return self
 
@@ -740,9 +768,6 @@ class Crew(FlowTrackable, BaseModel):
             )
             raise
         finally:
-            # Ensure all background memory saves complete before returning
-            if self._memory is not None and hasattr(self._memory, "drain_writes"):
-                self._memory.drain_writes()
             clear_files(self.id)
             detach(token)
 
@@ -1298,11 +1323,6 @@ class Crew(FlowTrackable, BaseModel):
         if agent and (hasattr(agent, "mcps") and getattr(agent, "mcps", None)):
             tools = self._add_mcp_tools(task, tools)
 
-        # Add memory tools if memory is available (agent or crew level)
-        resolved_memory = getattr(agent, "memory", None) or self._memory
-        if resolved_memory is not None:
-            tools = self._add_memory_tools(tools, resolved_memory)
-
         files = get_all_files(self.id, task.id)
         if files:
             supported_types: list[str] = []
@@ -1410,22 +1430,6 @@ class Crew(FlowTrackable, BaseModel):
             return self._merge_tools(tools, cast(list[BaseTool], code_tools))
         return tools
 
-    def _add_memory_tools(
-        self, tools: list[BaseTool], memory: Any
-    ) -> list[BaseTool]:
-        """Add recall and remember tools when memory is available.
-
-        Args:
-            tools: Current list of tools.
-            memory: The resolved Memory, MemoryScope, or MemorySlice instance.
-
-        Returns:
-            Updated list with memory tools added.
-        """
-        from crewai.tools.memory_tools import create_memory_tools
-
-        return self._merge_tools(tools, create_memory_tools(memory))
-
     def _add_file_tools(
         self, tools: list[BaseTool], files: dict[str, Any]
     ) -> list[BaseTool]:
@@ -1670,7 +1674,10 @@ class Crew(FlowTrackable, BaseModel):
             "_execution_span",
             "_file_handler",
             "_cache_handler",
-            "_memory",
+            "_short_term_memory",
+            "_long_term_memory",
+            "_entity_memory",
+            "_external_memory",
             "agents",
             "tasks",
             "knowledge_sources",
@@ -1704,8 +1711,18 @@ class Crew(FlowTrackable, BaseModel):
 
         copied_data = self.model_dump(exclude=exclude)
         copied_data = {k: v for k, v in copied_data.items() if v is not None}
-        if getattr(self, "_memory", None):
-            copied_data["memory"] = self._memory
+        if self.short_term_memory:
+            copied_data["short_term_memory"] = self.short_term_memory.model_copy(
+                deep=True
+            )
+        if self.long_term_memory:
+            copied_data["long_term_memory"] = self.long_term_memory.model_copy(
+                deep=True
+            )
+        if self.entity_memory:
+            copied_data["entity_memory"] = self.entity_memory.model_copy(deep=True)
+        if self.external_memory:
+            copied_data["external_memory"] = self.external_memory.model_copy(deep=True)
 
         copied_data.pop("agents", None)
         copied_data.pop("tasks", None)
@@ -1836,24 +1853,23 @@ class Crew(FlowTrackable, BaseModel):
 
         Args:
             command_type: Type of memory to reset.
-                Valid options: 'memory', 'knowledge', 'agent_knowledge',
-                'kickoff_outputs', or 'all'. Legacy names 'long', 'short',
-                'entity', 'external' are treated as 'memory'.
+                Valid options: 'long', 'short', 'entity', 'knowledge', 'agent_knowledge'
+                'kickoff_outputs', or 'all'
 
         Raises:
             ValueError: If an invalid command type is provided.
             RuntimeError: If memory reset operation fails.
         """
-        legacy_memory = frozenset(["long", "short", "entity", "external"])
-        if command_type in legacy_memory:
-            command_type = "memory"
         valid_types = frozenset(
             [
-                "memory",
+                "long",
+                "short",
+                "entity",
                 "knowledge",
                 "agent_knowledge",
                 "kickoff_outputs",
                 "all",
+                "external",
             ]
         )
 
@@ -1959,10 +1975,25 @@ class Crew(FlowTrackable, BaseModel):
         ) + agent_knowledges
 
         return {
-            "memory": {
-                "system": getattr(self, "_memory", None),
+            "short": {
+                "system": getattr(self, "_short_term_memory", None),
                 "reset": default_reset,
-                "name": "Memory",
+                "name": "Short Term",
+            },
+            "entity": {
+                "system": getattr(self, "_entity_memory", None),
+                "reset": default_reset,
+                "name": "Entity",
+            },
+            "external": {
+                "system": getattr(self, "_external_memory", None),
+                "reset": default_reset,
+                "name": "External",
+            },
+            "long": {
+                "system": getattr(self, "_long_term_memory", None),
+                "reset": default_reset,
+                "name": "Long Term",
             },
             "kickoff_outputs": {
                 "system": getattr(self, "_task_output_handler", None),

lib/crewai/src/crewai/events/__init__.py

@@ -63,7 +63,6 @@ from crewai.events.types.logging_events import (
     AgentLogsStartedEvent,
 )
 from crewai.events.types.mcp_events import (
-    MCPConfigFetchFailedEvent,
     MCPConnectionCompletedEvent,
     MCPConnectionFailedEvent,
     MCPConnectionStartedEvent,
@@ -166,7 +165,6 @@ __all__ = [
     "LiteAgentExecutionCompletedEvent",
     "LiteAgentExecutionErrorEvent",
     "LiteAgentExecutionStartedEvent",
-    "MCPConfigFetchFailedEvent",
     "MCPConnectionCompletedEvent",
     "MCPConnectionFailedEvent",
     "MCPConnectionStartedEvent",

lib/crewai/src/crewai/events/event_listener.py

@@ -68,7 +68,6 @@ from crewai.events.types.logging_events import (
     AgentLogsStartedEvent,
 )
 from crewai.events.types.mcp_events import (
-    MCPConfigFetchFailedEvent,
     MCPConnectionCompletedEvent,
     MCPConnectionFailedEvent,
     MCPConnectionStartedEvent,
@@ -666,16 +665,6 @@ class EventListener(BaseEventListener):
                 event.error_type,
             )
 
-        @crewai_event_bus.on(MCPConfigFetchFailedEvent)
-        def on_mcp_config_fetch_failed(
-            _: Any, event: MCPConfigFetchFailedEvent
-        ) -> None:
-            self.formatter.handle_mcp_config_fetch_failed(
-                event.slug,
-                event.error,
-                event.error_type,
-            )
-
         @crewai_event_bus.on(MCPToolExecutionStartedEvent)
         def on_mcp_tool_execution_started(
             _: Any, event: MCPToolExecutionStartedEvent

lib/crewai/src/crewai/events/event_types.py

@@ -67,7 +67,6 @@ from crewai.events.types.llm_guardrail_events import (
     LLMGuardrailStartedEvent,
 )
 from crewai.events.types.mcp_events import (
-    MCPConfigFetchFailedEvent,
     MCPConnectionCompletedEvent,
     MCPConnectionFailedEvent,
     MCPConnectionStartedEvent,
@@ -182,5 +181,4 @@ EventTypes = (
     | MCPToolExecutionStartedEvent
     | MCPToolExecutionCompletedEvent
     | MCPToolExecutionFailedEvent
-    | MCPConfigFetchFailedEvent
 )

lib/crewai/src/crewai/events/types/flow_events.py

@@ -120,52 +120,6 @@ class FlowPlotEvent(FlowEvent):
     type: str = "flow_plot"
 
 
-class FlowInputRequestedEvent(FlowEvent):
-    """Event emitted when a flow requests user input via ``Flow.ask()``.
-
-    This event is emitted before the flow suspends waiting for user input,
-    allowing UI frameworks and observability tools to know when a flow
-    needs user interaction.
-
-    Attributes:
-        flow_name: Name of the flow requesting input.
-        method_name: Name of the flow method that called ``ask()``.
-        message: The question or prompt being shown to the user.
-        metadata: Optional metadata sent with the question (e.g., user ID,
-            channel, session context).
-    """
-
-    method_name: str
-    message: str
-    metadata: dict[str, Any] | None = None
-    type: str = "flow_input_requested"
-
-
-class FlowInputReceivedEvent(FlowEvent):
-    """Event emitted when user input is received after ``Flow.ask()``.
-
-    This event is emitted after the user provides input (or the request
-    times out), allowing UI frameworks and observability tools to track
-    input collection.
-
-    Attributes:
-        flow_name: Name of the flow that received input.
-        method_name: Name of the flow method that called ``ask()``.
-        message: The original question or prompt.
-        response: The user's response, or None if timed out / unavailable.
-        metadata: Optional metadata sent with the question.
-        response_metadata: Optional metadata from the provider about the
-            response (e.g., who responded, thread ID, timestamps).
-    """
-
-    method_name: str
-    message: str
-    response: str | None = None
-    metadata: dict[str, Any] | None = None
-    response_metadata: dict[str, Any] | None = None
-    type: str = "flow_input_received"
-
-
 class HumanFeedbackRequestedEvent(FlowEvent):
     """Event emitted when human feedback is requested.
 

lib/crewai/src/crewai/events/types/mcp_events.py

@@ -83,16 +83,3 @@ class MCPToolExecutionFailedEvent(MCPEvent):
     error_type: str | None = None  # "timeout", "validation", "server_error", etc.
     started_at: datetime | None = None
     failed_at: datetime | None = None
-
-
-class MCPConfigFetchFailedEvent(BaseEvent):
-    """Event emitted when fetching an AMP MCP server config fails.
-
-    This covers cases where the slug is not connected, the API call
-    failed, or native MCP resolution failed after config was fetched.
-    """
-
-    type: str = "mcp_config_fetch_failed"
-    slug: str
-    error: str
-    error_type: str | None = None  # "not_connected", "api_error", "connection_failed"

lib/crewai/src/crewai/events/utils/console_formatter.py

@@ -170,16 +170,16 @@ To enable tracing, do any one of these:
         """Create standardized status content with consistent formatting."""
         content = Text()
         content.append(f"{title}\n", style=f"{status_style} bold")
-        content.append("Name: ", style="white")
+        content.append("Name: \n", style="white")
         content.append(f"{name}\n", style=status_style)
 
         for label, value in fields.items():
-            content.append(f"{label}: ", style="white")
+            content.append(f"{label}: \n", style="white")
             content.append(
                 f"{value}\n", style=fields.get(f"{label}_style", status_style)
             )
         if tool_args:
-            content.append("Tool Args: ", style="white")
+            content.append("Tool Args: \n", style="white")
             content.append(f"{tool_args}\n", style=status_style)
 
         return content
@@ -737,27 +737,6 @@ To enable tracing, do any one of these:
 
         self.print_panel(content, title, style)
 
-    @staticmethod
-    def _simplify_tools_field(fields: dict[str, Any]) -> dict[str, Any]:
-        """Simplify the tools field to show only tool names instead of full definitions.
-
-        Args:
-            fields: Dictionary of fields that may contain a 'tools' key with
-                    full tool objects.
-
-        Returns:
-            The fields dictionary with 'tools' replaced by a comma-separated
-            string of tool names.
-        """
-        if "tools" in fields:
-            tools = fields["tools"]
-            if tools:
-                tool_names = [getattr(t, "name", str(t)) for t in tools]
-                fields["tools"] = ", ".join(tool_names) if tool_names else "None"
-            else:
-                fields["tools"] = "None"
-        return fields
-
     def handle_lite_agent_execution(
         self,
         lite_agent_role: str,
@@ -769,8 +748,6 @@ To enable tracing, do any one of these:
         if not self.verbose:
             return
 
-        fields = self._simplify_tools_field(fields)
-
         if status == "started":
             self.create_lite_agent_branch(lite_agent_role)
             if fields:
@@ -1512,34 +1489,6 @@ To enable tracing, do any one of these:
         self.print(panel)
         self.print()
 
-    def handle_mcp_config_fetch_failed(
-        self,
-        slug: str,
-        error: str = "",
-        error_type: str | None = None,
-    ) -> None:
-        """Handle MCP config fetch failed event (AMP resolution failures)."""
-        if not self.verbose:
-            return
-
-        content = Text()
-        content.append("MCP Config Fetch Failed\n\n", style="red bold")
-        content.append("Server: ", style="white")
-        content.append(f"{slug}\n", style="red")
-
-        if error_type:
-            content.append("Error Type: ", style="white")
-            content.append(f"{error_type}\n", style="red")
-
-        if error:
-            content.append("\nError: ", style="white bold")
-            error_preview = error[:500] + "..." if len(error) > 500 else error
-            content.append(f"{error_preview}\n", style="red")
-
-        panel = self.create_panel(content, "❌ MCP Config Failed", "red")
-        self.print(panel)
-        self.print()
-
     def handle_mcp_tool_execution_started(
         self,
         server_name: str,

lib/crewai/src/crewai/experimental/agent_executor.py

@@ -1,10 +1,7 @@
 from __future__ import annotations
 
-import asyncio
 from collections.abc import Callable, Coroutine
-from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime
-import inspect
 import json
 import threading
 from typing import TYPE_CHECKING, Any, Literal, cast
@@ -52,8 +49,6 @@ from crewai.hooks.types import (
     BeforeLLMCallHookCallable,
     BeforeLLMCallHookType,
 )
-from crewai.tools.base_tool import BaseTool
-from crewai.tools.structured_tool import CrewStructuredTool
 from crewai.utilities.agent_utils import (
     convert_tools_to_openai_schema,
     enforce_rpm_limit,
@@ -68,7 +63,6 @@ from crewai.utilities.agent_utils import (
     has_reached_max_iterations,
     is_context_length_exceeded,
     is_inside_event_loop,
-    parse_tool_call_args,
     process_llm_response,
     track_delegation_if_needed,
 )
@@ -87,6 +81,8 @@ if TYPE_CHECKING:
     from crewai.crew import Crew
     from crewai.llms.base_llm import BaseLLM
     from crewai.task import Task
+    from crewai.tools.base_tool import BaseTool
+    from crewai.tools.structured_tool import CrewStructuredTool
     from crewai.tools.tool_types import ToolResult
     from crewai.utilities.prompts import StandardPromptResult, SystemPromptResult
 
@@ -321,7 +317,7 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
     def _setup_native_tools(self) -> None:
         """Convert tools to OpenAI schema format for native function calling."""
         if self.original_tools:
-            self._openai_tools, self._available_functions, self._tool_name_mapping = (
+            self._openai_tools, self._available_functions = (
                 convert_tools_to_openai_schema(self.original_tools)
             )
 
@@ -594,19 +590,21 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
     def execute_tool_action(self) -> Literal["tool_completed", "tool_result_is_final"]:
         """Execute the tool action and handle the result."""
 
-        action = cast(AgentAction, self.state.current_answer)
-
-        fingerprint_context = {}
-        if (
-            self.agent
-            and hasattr(self.agent, "security_config")
-            and hasattr(self.agent.security_config, "fingerprint")
-        ):
-            fingerprint_context = {
-                "agent_fingerprint": str(self.agent.security_config.fingerprint)
-            }
-
         try:
+            action = cast(AgentAction, self.state.current_answer)
+
+            # Extract fingerprint context for tool execution
+            fingerprint_context = {}
+            if (
+                self.agent
+                and hasattr(self.agent, "security_config")
+                and hasattr(self.agent.security_config, "fingerprint")
+            ):
+                fingerprint_context = {
+                    "agent_fingerprint": str(self.agent.security_config.fingerprint)
+                }
+
+            # Execute the tool
             tool_result = execute_tool_and_check_finality(
                 agent_action=action,
                 fingerprint_context=fingerprint_context,
@@ -620,19 +618,24 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                 function_calling_llm=self.function_calling_llm,
                 crew=self.crew,
             )
-        except Exception as e:
-            if self.agent and self.agent.verbose:
-                self._printer.print(
-                    content=f"Error in tool execution: {e}", color="red"
-                )
-            if self.task:
-                self.task.increment_tools_errors()
 
-            error_observation = f"\nObservation: Error executing tool: {e}"
-            action.text += error_observation
-            action.result = str(e)
-            self._append_message_to_state(action.text)
+            # Handle agent action and append observation to messages
+            result = self._handle_agent_action(action, tool_result)
+            self.state.current_answer = result
 
+            # Invoke step callback if configured
+            self._invoke_step_callback(result)
+
+            # Append result message to conversation state
+            if hasattr(result, "text"):
+                self._append_message_to_state(result.text)
+
+            # Check if tool result became a final answer (result_as_answer flag)
+            if isinstance(result, AgentFinish):
+                self.state.is_finished = True
+                return "tool_result_is_final"
+
+            # Inject post-tool reasoning prompt to enforce analysis
             reasoning_prompt = self._i18n.slice("post_tool_reasoning")
             reasoning_message: LLMMessage = {
                 "role": "user",
@@ -642,26 +645,12 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
 
             return "tool_completed"
 
-        result = self._handle_agent_action(action, tool_result)
-        self.state.current_answer = result
-
-        self._invoke_step_callback(result)
-
-        if hasattr(result, "text"):
-            self._append_message_to_state(result.text)
-
-        if isinstance(result, AgentFinish):
-            self.state.is_finished = True
-            return "tool_result_is_final"
-
-        reasoning_prompt = self._i18n.slice("post_tool_reasoning")
-        reasoning_message: LLMMessage = {
-            "role": "user",
-            "content": reasoning_prompt,
-        }
-        self.state.messages.append(reasoning_message)
-
-        return "tool_completed"
+        except Exception as e:
+            error_text = Text()
+            error_text.append("❌ Error in tool execution: ", style="red bold")
+            error_text.append(str(e), style="red")
+            self._console.print(error_text)
+            raise
 
     @listen("native_tool_calls")
     def execute_native_tool(
@@ -679,12 +668,9 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
         if not self.state.pending_tool_calls:
             return "native_tool_completed"
 
-        pending_tool_calls = list(self.state.pending_tool_calls)
-        self.state.pending_tool_calls.clear()
-
         # Group all tool calls into a single assistant message
         tool_calls_to_report = []
-        for tool_call in pending_tool_calls:
+        for tool_call in self.state.pending_tool_calls:
             info = extract_tool_call_info(tool_call)
             if not info:
                 continue
@@ -709,99 +695,202 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                 "content": None,
                 "tool_calls": tool_calls_to_report,
             }
-            if all(type(tc).__qualname__ == "Part" for tc in pending_tool_calls):
-                assistant_message["raw_tool_call_parts"] = list(pending_tool_calls)
+            if all(
+                type(tc).__qualname__ == "Part" for tc in self.state.pending_tool_calls
+            ):
+                assistant_message["raw_tool_call_parts"] = list(
+                    self.state.pending_tool_calls
+                )
             self.state.messages.append(assistant_message)
 
-        runnable_tool_calls = [
-            tool_call
-            for tool_call in pending_tool_calls
-            if extract_tool_call_info(tool_call) is not None
-        ]
-        should_parallelize = self._should_parallelize_native_tool_calls(
-            runnable_tool_calls
-        )
+        # Now execute each tool
+        while self.state.pending_tool_calls:
+            tool_call = self.state.pending_tool_calls.pop(0)
+            info = extract_tool_call_info(tool_call)
+            if not info:
+                continue
 
-        execution_results: list[dict[str, Any]] = []
-        if should_parallelize:
-            max_workers = min(8, len(runnable_tool_calls))
-            with ThreadPoolExecutor(max_workers=max_workers) as pool:
-                future_to_idx = {
-                    pool.submit(self._execute_single_native_tool_call, tool_call): idx
-                    for idx, tool_call in enumerate(runnable_tool_calls)
-                }
-                ordered_results: list[dict[str, Any] | None] = [None] * len(
-                    runnable_tool_calls
+            call_id, func_name, func_args = info
+
+            # Parse arguments
+            if isinstance(func_args, str):
+                try:
+                    args_dict = json.loads(func_args)
+                except json.JSONDecodeError:
+                    args_dict = {}
+            else:
+                args_dict = func_args
+
+            # Get agent_key for event tracking
+            agent_key = (
+                getattr(self.agent, "key", "unknown") if self.agent else "unknown"
+            )
+
+            # Find original tool by matching sanitized name (needed for cache_function and result_as_answer)
+            original_tool = None
+            for tool in self.original_tools or []:
+                if sanitize_tool_name(tool.name) == func_name:
+                    original_tool = tool
+                    break
+
+            # Check if tool has reached max usage count
+            max_usage_reached = False
+            if (
+                original_tool
+                and original_tool.max_usage_count is not None
+                and original_tool.current_usage_count >= original_tool.max_usage_count
+            ):
+                max_usage_reached = True
+
+            # Check cache before executing
+            from_cache = False
+            input_str = json.dumps(args_dict) if args_dict else ""
+            if self.tools_handler and self.tools_handler.cache:
+                cached_result = self.tools_handler.cache.read(
+                    tool=func_name, input=input_str
                 )
-                for future in as_completed(future_to_idx):
-                    idx = future_to_idx[future]
-                    try:
-                        ordered_results[idx] = future.result()
-                    except Exception as e:
-                        tool_call = runnable_tool_calls[idx]
-                        info = extract_tool_call_info(tool_call)
-                        call_id = info[0] if info else "unknown"
-                        func_name = info[1] if info else "unknown"
-                        ordered_results[idx] = {
-                            "call_id": call_id,
-                            "func_name": func_name,
-                            "result": f"Error executing tool: {e}",
-                            "from_cache": False,
-                            "original_tool": None,
-                        }
-                execution_results = [
-                    result for result in ordered_results if result is not None
-                ]
-        else:
-            # Execute sequentially so result_as_answer tools can short-circuit
-            # immediately without running remaining calls.
-            for tool_call in runnable_tool_calls:
-                execution_result = self._execute_single_native_tool_call(tool_call)
-                call_id = cast(str, execution_result["call_id"])
-                func_name = cast(str, execution_result["func_name"])
-                result = cast(str, execution_result["result"])
-                from_cache = cast(bool, execution_result["from_cache"])
-                original_tool = execution_result["original_tool"]
+                if cached_result is not None:
+                    result = (
+                        str(cached_result)
+                        if not isinstance(cached_result, str)
+                        else cached_result
+                    )
+                    from_cache = True
 
-                tool_message: LLMMessage = {
-                    "role": "tool",
-                    "tool_call_id": call_id,
-                    "name": func_name,
-                    "content": result,
-                }
-                self.state.messages.append(tool_message)
+            # Emit tool usage started event
+            started_at = datetime.now()
+            crewai_event_bus.emit(
+                self,
+                event=ToolUsageStartedEvent(
+                    tool_name=func_name,
+                    tool_args=args_dict,
+                    from_agent=self.agent,
+                    from_task=self.task,
+                    agent_key=agent_key,
+                ),
+            )
+            error_event_emitted = False
 
-                # Log the tool execution
-                if self.agent and self.agent.verbose:
-                    cache_info = " (from cache)" if from_cache else ""
+            track_delegation_if_needed(func_name, args_dict, self.task)
+
+            structured_tool: CrewStructuredTool | None = None
+            for structured in self.tools or []:
+                if sanitize_tool_name(structured.name) == func_name:
+                    structured_tool = structured
+                    break
+
+            hook_blocked = False
+            before_hook_context = ToolCallHookContext(
+                tool_name=func_name,
+                tool_input=args_dict,
+                tool=structured_tool,  # type: ignore[arg-type]
+                agent=self.agent,
+                task=self.task,
+                crew=self.crew,
+            )
+            before_hooks = get_before_tool_call_hooks()
+            try:
+                for hook in before_hooks:
+                    hook_result = hook(before_hook_context)
+                    if hook_result is False:
+                        hook_blocked = True
+                        break
+            except Exception as hook_error:
+                if self.agent.verbose:
                     self._printer.print(
-                        content=f"Tool {func_name} executed with result{cache_info}: {result[:200]}...",
-                        color="green",
+                        content=f"Error in before_tool_call hook: {hook_error}",
+                        color="red",
                     )
 
-                if (
-                    original_tool
-                    and hasattr(original_tool, "result_as_answer")
-                    and original_tool.result_as_answer
-                ):
-                    self.state.current_answer = AgentFinish(
-                        thought="Tool result is the final answer",
+            if hook_blocked:
+                result = f"Tool execution blocked by hook. Tool: {func_name}"
+            elif not from_cache and not max_usage_reached:
+                result = "Tool not found"
+                if func_name in self._available_functions:
+                    try:
+                        tool_func = self._available_functions[func_name]
+                        raw_result = tool_func(**args_dict)
+
+                        # Add to cache after successful execution (before string conversion)
+                        if self.tools_handler and self.tools_handler.cache:
+                            should_cache = True
+                            if original_tool:
+                                should_cache = original_tool.cache_function(
+                                    args_dict, raw_result
+                                )
+                            if should_cache:
+                                self.tools_handler.cache.add(
+                                    tool=func_name, input=input_str, output=raw_result
+                                )
+
+                        # Convert to string for message
+                        result = (
+                            str(raw_result)
+                            if not isinstance(raw_result, str)
+                            else raw_result
+                        )
+                    except Exception as e:
+                        result = f"Error executing tool: {e}"
+                        if self.task:
+                            self.task.increment_tools_errors()
+                        # Emit tool usage error event
+                        crewai_event_bus.emit(
+                            self,
+                            event=ToolUsageErrorEvent(
+                                tool_name=func_name,
+                                tool_args=args_dict,
+                                from_agent=self.agent,
+                                from_task=self.task,
+                                agent_key=agent_key,
+                                error=e,
+                            ),
+                        )
+                        error_event_emitted = True
+            elif max_usage_reached and original_tool:
+                # Return error message when max usage limit is reached
+                result = f"Tool '{func_name}' has reached its usage limit of {original_tool.max_usage_count} times and cannot be used anymore."
+
+            # Execute after_tool_call hooks (even if blocked, to allow logging/monitoring)
+            after_hook_context = ToolCallHookContext(
+                tool_name=func_name,
+                tool_input=args_dict,
+                tool=structured_tool,  # type: ignore[arg-type]
+                agent=self.agent,
+                task=self.task,
+                crew=self.crew,
+                tool_result=result,
+            )
+            after_hooks = get_after_tool_call_hooks()
+            try:
+                for after_hook in after_hooks:
+                    after_hook_result = after_hook(after_hook_context)
+                    if after_hook_result is not None:
+                        result = after_hook_result
+                        after_hook_context.tool_result = result
+            except Exception as hook_error:
+                if self.agent.verbose:
+                    self._printer.print(
+                        content=f"Error in after_tool_call hook: {hook_error}",
+                        color="red",
+                    )
+
+            if not error_event_emitted:
+                crewai_event_bus.emit(
+                    self,
+                    event=ToolUsageFinishedEvent(
                         output=result,
-                        text=result,
-                    )
-                    self.state.is_finished = True
-                    return "tool_result_is_final"
+                        tool_name=func_name,
+                        tool_args=args_dict,
+                        from_agent=self.agent,
+                        from_task=self.task,
+                        agent_key=agent_key,
+                        started_at=started_at,
+                        finished_at=datetime.now(),
+                    ),
+                )
 
-            return "native_tool_completed"
-
-        for execution_result in execution_results:
-            call_id = cast(str, execution_result["call_id"])
-            func_name = cast(str, execution_result["func_name"])
-            result = cast(str, execution_result["result"])
-            from_cache = cast(bool, execution_result["from_cache"])
-            original_tool = execution_result["original_tool"]
-
-            tool_message = {
+            # Append tool result message
+            tool_message: LLMMessage = {
                 "role": "tool",
                 "tool_call_id": call_id,
                 "name": func_name,
@@ -833,248 +922,6 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
 
         return "native_tool_completed"
 
-    def _should_parallelize_native_tool_calls(self, tool_calls: list[Any]) -> bool:
-        """Determine if native tool calls are safe to run in parallel."""
-        if len(tool_calls) <= 1:
-            return False
-
-        for tool_call in tool_calls:
-            info = extract_tool_call_info(tool_call)
-            if not info:
-                continue
-            _, func_name, _ = info
-
-            mapping = getattr(self, "_tool_name_mapping", None)
-            original_tool: BaseTool | None = None
-            if mapping and func_name in mapping:
-                mapped = mapping[func_name]
-                if isinstance(mapped, BaseTool):
-                    original_tool = mapped
-            if original_tool is None:
-                for tool in self.original_tools or []:
-                    if sanitize_tool_name(tool.name) == func_name:
-                        original_tool = tool
-                        break
-
-            if not original_tool:
-                continue
-
-            if getattr(original_tool, "result_as_answer", False):
-                return False
-            if getattr(original_tool, "max_usage_count", None) is not None:
-                return False
-
-        return True
-
-    def _execute_single_native_tool_call(self, tool_call: Any) -> dict[str, Any]:
-        """Execute a single native tool call and return metadata/result."""
-        info = extract_tool_call_info(tool_call)
-        if not info:
-            call_id = (
-                getattr(tool_call, "id", None)
-                or (tool_call.get("id") if isinstance(tool_call, dict) else None)
-                or "unknown"
-            )
-            return {
-                "call_id": call_id,
-                "func_name": "unknown",
-                "result": "Error: Invalid native tool call format",
-                "from_cache": False,
-                "original_tool": None,
-            }
-
-        call_id, func_name, func_args = info
-
-        # Parse arguments
-        args_dict, parse_error = parse_tool_call_args(func_args, func_name, call_id)
-        if parse_error is not None:
-            return parse_error
-
-        # Get agent_key for event tracking
-        agent_key = getattr(self.agent, "key", "unknown") if self.agent else "unknown"
-
-        original_tool: BaseTool | None = None
-        mapping = getattr(self, "_tool_name_mapping", None)
-        if mapping and func_name in mapping:
-            mapped = mapping[func_name]
-            if isinstance(mapped, BaseTool):
-                original_tool = mapped
-        if original_tool is None:
-            for tool in self.original_tools or []:
-                if sanitize_tool_name(tool.name) == func_name:
-                    original_tool = tool
-                    break
-
-        # Check if tool has reached max usage count
-        max_usage_reached = False
-        if (
-            original_tool
-            and original_tool.max_usage_count is not None
-            and original_tool.current_usage_count >= original_tool.max_usage_count
-        ):
-            max_usage_reached = True
-
-        # Check cache before executing
-        from_cache = False
-        input_str = json.dumps(args_dict) if args_dict else ""
-        if self.tools_handler and self.tools_handler.cache:
-            cached_result = self.tools_handler.cache.read(
-                tool=func_name, input=input_str
-            )
-            if cached_result is not None:
-                result = (
-                    str(cached_result)
-                    if not isinstance(cached_result, str)
-                    else cached_result
-                )
-                from_cache = True
-
-        # Emit tool usage started event
-        started_at = datetime.now()
-        crewai_event_bus.emit(
-            self,
-            event=ToolUsageStartedEvent(
-                tool_name=func_name,
-                tool_args=args_dict,
-                from_agent=self.agent,
-                from_task=self.task,
-                agent_key=agent_key,
-            ),
-        )
-        error_event_emitted = False
-
-        track_delegation_if_needed(func_name, args_dict, self.task)
-
-        structured_tool: CrewStructuredTool | None = None
-        if original_tool is not None:
-            for structured in self.tools or []:
-                if getattr(structured, "_original_tool", None) is original_tool:
-                    structured_tool = structured
-                    break
-        if structured_tool is None:
-            for structured in self.tools or []:
-                if sanitize_tool_name(structured.name) == func_name:
-                    structured_tool = structured
-                    break
-
-        hook_blocked = False
-        before_hook_context = ToolCallHookContext(
-            tool_name=func_name,
-            tool_input=args_dict,
-            tool=structured_tool,  # type: ignore[arg-type]
-            agent=self.agent,
-            task=self.task,
-            crew=self.crew,
-        )
-        before_hooks = get_before_tool_call_hooks()
-        try:
-            for hook in before_hooks:
-                hook_result = hook(before_hook_context)
-                if hook_result is False:
-                    hook_blocked = True
-                    break
-        except Exception as hook_error:
-            if self.agent.verbose:
-                self._printer.print(
-                    content=f"Error in before_tool_call hook: {hook_error}",
-                    color="red",
-                )
-
-        if hook_blocked:
-            result = f"Tool execution blocked by hook. Tool: {func_name}"
-        elif not from_cache and not max_usage_reached:
-            result = "Tool not found"
-            if func_name in self._available_functions:
-                try:
-                    tool_func = self._available_functions[func_name]
-                    raw_result = tool_func(**args_dict)
-
-                    # Add to cache after successful execution (before string conversion)
-                    if self.tools_handler and self.tools_handler.cache:
-                        should_cache = True
-                        if original_tool:
-                            should_cache = original_tool.cache_function(
-                                args_dict, raw_result
-                            )
-                        if should_cache:
-                            self.tools_handler.cache.add(
-                                tool=func_name, input=input_str, output=raw_result
-                            )
-
-                    # Convert to string for message
-                    result = (
-                        str(raw_result)
-                        if not isinstance(raw_result, str)
-                        else raw_result
-                    )
-                except Exception as e:
-                    result = f"Error executing tool: {e}"
-                    if self.task:
-                        self.task.increment_tools_errors()
-                    # Emit tool usage error event
-                    crewai_event_bus.emit(
-                        self,
-                        event=ToolUsageErrorEvent(
-                            tool_name=func_name,
-                            tool_args=args_dict,
-                            from_agent=self.agent,
-                            from_task=self.task,
-                            agent_key=agent_key,
-                            error=e,
-                        ),
-                    )
-                    error_event_emitted = True
-        elif max_usage_reached and original_tool:
-            # Return error message when max usage limit is reached
-            result = f"Tool '{func_name}' has reached its usage limit of {original_tool.max_usage_count} times and cannot be used anymore."
-
-        # Execute after_tool_call hooks (even if blocked, to allow logging/monitoring)
-        after_hook_context = ToolCallHookContext(
-            tool_name=func_name,
-            tool_input=args_dict,
-            tool=structured_tool,  # type: ignore[arg-type]
-            agent=self.agent,
-            task=self.task,
-            crew=self.crew,
-            tool_result=result,
-        )
-        after_hooks = get_after_tool_call_hooks()
-        try:
-            for after_hook in after_hooks:
-                after_hook_result = after_hook(after_hook_context)
-                if after_hook_result is not None:
-                    result = after_hook_result
-                    after_hook_context.tool_result = result
-        except Exception as hook_error:
-            if self.agent.verbose:
-                self._printer.print(
-                    content=f"Error in after_tool_call hook: {hook_error}",
-                    color="red",
-                )
-
-        if not error_event_emitted:
-            crewai_event_bus.emit(
-                self,
-                event=ToolUsageFinishedEvent(
-                    output=result,
-                    tool_name=func_name,
-                    tool_args=args_dict,
-                    from_agent=self.agent,
-                    from_task=self.task,
-                    agent_key=agent_key,
-                    started_at=started_at,
-                    finished_at=datetime.now(),
-                ),
-            )
-
-        return {
-            "call_id": call_id,
-            "func_name": func_name,
-            "result": result,
-            "from_cache": from_cache,
-            "original_tool": original_tool,
-        }
-
     def _extract_tool_name(self, tool_call: Any) -> str:
         """Extract tool name from various tool call formats."""
         if hasattr(tool_call, "function"):
@@ -1259,7 +1106,9 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
             if self.state.ask_for_human_input:
                 formatted_answer = self._handle_human_feedback(formatted_answer)
 
-            self._save_to_memory(formatted_answer)
+            self._create_short_term_memory(formatted_answer)
+            self._create_long_term_memory(formatted_answer)
+            self._create_external_memory(formatted_answer)
 
             return {"output": formatted_answer.output}
 
@@ -1342,7 +1191,9 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
             if self.state.ask_for_human_input:
                 formatted_answer = await self._ahandle_human_feedback(formatted_answer)
 
-            self._save_to_memory(formatted_answer)
+            self._create_short_term_memory(formatted_answer)
+            self._create_long_term_memory(formatted_answer)
+            self._create_external_memory(formatted_answer)
 
             return {"output": formatted_answer.output}
 
@@ -1405,9 +1256,7 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
             formatted_answer: Current agent response.
         """
         if self.step_callback:
-            cb_result = self.step_callback(formatted_answer)
-            if inspect.iscoroutine(cb_result):
-                asyncio.run(cb_result)
+            self.step_callback(formatted_answer)
 
     def _append_message_to_state(
         self, text: str, role: Literal["user", "assistant", "system"] = "assistant"

lib/crewai/src/crewai/flow/__init__.py

@@ -7,7 +7,6 @@ from crewai.flow.async_feedback import (
 from crewai.flow.flow import Flow, and_, listen, or_, router, start
 from crewai.flow.flow_config import flow_config
 from crewai.flow.human_feedback import HumanFeedbackResult, human_feedback
-from crewai.flow.input_provider import InputProvider, InputResponse
 from crewai.flow.persistence import persist
 from crewai.flow.visualization import (
     FlowStructure,
@@ -23,8 +22,6 @@ __all__ = [
     "HumanFeedbackPending",
     "HumanFeedbackProvider",
     "HumanFeedbackResult",
-    "InputProvider",
-    "InputResponse",
     "PendingFeedbackContext",
     "and_",
     "build_flow_structure",

lib/crewai/src/crewai/flow/async_feedback/providers.py

@@ -1,8 +1,7 @@
-"""Default provider implementations for human feedback and user input.
+"""Default provider implementations for human feedback.
 
 This module provides the ConsoleProvider, which is the default synchronous
-provider that collects both feedback (for ``@human_feedback``) and user input
-(for ``Flow.ask()``) via console.
+provider that collects feedback via console input.
 """
 
 from __future__ import annotations
@@ -17,23 +16,20 @@ if TYPE_CHECKING:
 
 
 class ConsoleProvider:
-    """Default synchronous console-based provider for feedback and input.
+    """Default synchronous console-based feedback provider.
 
     This provider blocks execution and waits for console input from the user.
-    It serves two purposes:
-
-    - **Feedback** (``request_feedback``): Used by ``@human_feedback`` to
-      display method output and collect review feedback.
-    - **Input** (``request_input``): Used by ``Flow.ask()`` to prompt the
-      user with a question and collect a response.
+    It displays the method output with formatting and prompts for feedback.
 
     This is the default provider used when no custom provider is specified
-    in the ``@human_feedback`` decorator or on the Flow's ``input_provider``.
+    in the @human_feedback decorator.
 
-    Example (feedback):
+    Example:
         ```python
         from crewai.flow.async_feedback import ConsoleProvider
 
+
+        # Explicitly use console provider
         @human_feedback(
             message="Review this:",
             provider=ConsoleProvider(),
@@ -41,20 +37,9 @@ class ConsoleProvider:
         def my_method(self):
             return "Content to review"
         ```
-
-    Example (input):
-        ```python
-        from crewai.flow import Flow, start
-
-        class MyFlow(Flow):
-            @start()
-            def gather_info(self):
-                topic = self.ask("What topic should we research?")
-                return topic
-        ```
     """
 
-    def __init__(self, verbose: bool = True) -> None:
+    def __init__(self, verbose: bool = True):
         """Initialize the console provider.
 
         Args:
@@ -139,55 +124,3 @@ class ConsoleProvider:
         finally:
             # Resume live updates
             formatter.resume_live_updates()
-
-    def request_input(
-        self,
-        message: str,
-        flow: Flow[Any],
-        metadata: dict[str, Any] | None = None,
-    ) -> str | None:
-        """Request user input via console (blocking).
-
-        Displays the prompt message with formatting and waits for the user
-        to type their response. Used by ``Flow.ask()``.
-
-        Unlike ``request_feedback``, this method does not display an
-        "OUTPUT FOR REVIEW" panel or emit feedback-specific events (those
-        are handled by ``ask()`` itself).
-
-        Args:
-            message: The question or prompt to display to the user.
-            flow: The Flow instance requesting input.
-            metadata: Optional metadata from the caller. Ignored by the
-                console provider (console has no concept of user routing).
-
-        Returns:
-            The user's input as a stripped string. Returns empty string
-            if user presses Enter without input. Never returns None
-            (console input is always available).
-        """
-        from crewai.events.event_listener import event_listener
-
-        # Pause live updates during human input
-        formatter = event_listener.formatter
-        formatter.pause_live_updates()
-
-        try:
-            console = formatter.console
-
-            if self.verbose:
-                console.print()
-                console.print(message, style="yellow")
-                console.print()
-
-                response = input(">>> \n").strip()
-            else:
-                response = input(f"{message} ").strip()
-
-            # Add line break after input so formatter output starts clean
-            console.print()
-
-            return response
-        finally:
-            # Resume live updates
-            formatter.resume_live_updates()

lib/crewai/src/crewai/flow/flow.py

@@ -10,15 +10,13 @@ import asyncio
 from collections.abc import (
     Callable,
     ItemsView,
-    Iterable,
     Iterator,
     KeysView,
     Sequence,
     ValuesView,
 )
-from concurrent.futures import Future, ThreadPoolExecutor
+from concurrent.futures import Future
 import copy
-import enum
 import inspect
 import logging
 import threading
@@ -29,10 +27,8 @@ from typing import (
     Generic,
     Literal,
     ParamSpec,
-    SupportsIndex,
     TypeVar,
     cast,
-    overload,
 )
 from uuid import uuid4
 
@@ -81,12 +77,7 @@ from crewai.flow.flow_wrappers import (
     StartMethod,
 )
 from crewai.flow.persistence.base import FlowPersistence
-from crewai.flow.types import (
-    FlowExecutionData,
-    FlowMethodName,
-    InputHistoryEntry,
-    PendingListenerKey,
-)
+from crewai.flow.types import FlowExecutionData, FlowMethodName, PendingListenerKey
 from crewai.flow.utils import (
     _extract_all_methods,
     _extract_all_methods_recursive,
@@ -425,17 +416,13 @@ def and_(*conditions: str | FlowCondition | Callable[..., Any]) -> FlowCondition
     return {"type": AND_CONDITION, "conditions": processed_conditions}
 
 
-class LockedListProxy(list, Generic[T]):  # type: ignore[type-arg]
+class LockedListProxy(Generic[T]):
     """Thread-safe proxy for list operations.
 
-    Subclasses ``list`` so that ``isinstance(proxy, list)`` returns True,
-    which is required by libraries like LanceDB and Pydantic that do strict
-    type checks. All mutations go through the lock; reads delegate to the
-    underlying list.
+    Wraps a list and uses a lock for all mutating operations.
     """
 
     def __init__(self, lst: list[T], lock: threading.Lock) -> None:
-        super().__init__()  # empty builtin list; all access goes through self._list
         self._list = lst
         self._lock = lock
 
@@ -443,11 +430,11 @@ class LockedListProxy(list, Generic[T]):  # type: ignore[type-arg]
         with self._lock:
             self._list.append(item)
 
-    def extend(self, items: Iterable[T]) -> None:
+    def extend(self, items: list[T]) -> None:
         with self._lock:
             self._list.extend(items)
 
-    def insert(self, index: SupportsIndex, item: T) -> None:
+    def insert(self, index: int, item: T) -> None:
         with self._lock:
             self._list.insert(index, item)
 
@@ -455,7 +442,7 @@ class LockedListProxy(list, Generic[T]):  # type: ignore[type-arg]
         with self._lock:
             self._list.remove(item)
 
-    def pop(self, index: SupportsIndex = -1) -> T:
+    def pop(self, index: int = -1) -> T:
         with self._lock:
             return self._list.pop(index)
 
@@ -463,23 +450,15 @@ class LockedListProxy(list, Generic[T]):  # type: ignore[type-arg]
         with self._lock:
             self._list.clear()
 
-    @overload
-    def __setitem__(self, index: SupportsIndex, value: T) -> None: ...
-    @overload
-    def __setitem__(self, index: slice, value: Iterable[T]) -> None: ...
-    def __setitem__(self, index: Any, value: Any) -> None:
+    def __setitem__(self, index: int, value: T) -> None:
         with self._lock:
             self._list[index] = value
 
-    def __delitem__(self, index: SupportsIndex | slice) -> None:
+    def __delitem__(self, index: int) -> None:
         with self._lock:
             del self._list[index]
 
-    @overload
-    def __getitem__(self, index: SupportsIndex) -> T: ...
-    @overload
-    def __getitem__(self, index: slice) -> list[T]: ...
-    def __getitem__(self, index: Any) -> Any:
+    def __getitem__(self, index: int) -> T:
         return self._list[index]
 
     def __len__(self) -> int:
@@ -497,31 +476,14 @@ class LockedListProxy(list, Generic[T]):  # type: ignore[type-arg]
     def __bool__(self) -> bool:
         return bool(self._list)
 
-    def __eq__(self, other: object) -> bool:
-        """Compare based on the underlying list contents."""
-        if isinstance(other, LockedListProxy):
-            # Avoid deadlocks by acquiring locks in a consistent order.
-            first, second = (self, other) if id(self) <= id(other) else (other, self)
-            with first._lock:
-                with second._lock:
-                    return first._list == second._list
-        with self._lock:
-            return self._list == other
 
-    def __ne__(self, other: object) -> bool:
-        return not self.__eq__(other)
-
-
-class LockedDictProxy(dict, Generic[T]):  # type: ignore[type-arg]
+class LockedDictProxy(Generic[T]):
     """Thread-safe proxy for dict operations.
 
-    Subclasses ``dict`` so that ``isinstance(proxy, dict)`` returns True,
-    which is required by libraries like Pydantic that do strict type checks.
-    All mutations go through the lock; reads delegate to the underlying dict.
+    Wraps a dict and uses a lock for all mutating operations.
     """
 
     def __init__(self, d: dict[str, T], lock: threading.Lock) -> None:
-        super().__init__()  # empty builtin dict; all access goes through self._dict
         self._dict = d
         self._lock = lock
 
@@ -533,11 +495,11 @@ class LockedDictProxy(dict, Generic[T]):  # type: ignore[type-arg]
         with self._lock:
             del self._dict[key]
 
-    def pop(self, key: str, *default: T) -> T:  # type: ignore[override]
+    def pop(self, key: str, *default: T) -> T:
         with self._lock:
             return self._dict.pop(key, *default)
 
-    def update(self, other: dict[str, T]) -> None:  # type: ignore[override]
+    def update(self, other: dict[str, T]) -> None:
         with self._lock:
             self._dict.update(other)
 
@@ -545,7 +507,7 @@ class LockedDictProxy(dict, Generic[T]):  # type: ignore[type-arg]
         with self._lock:
             self._dict.clear()
 
-    def setdefault(self, key: str, default: T) -> T:  # type: ignore[override]
+    def setdefault(self, key: str, default: T) -> T:
         with self._lock:
             return self._dict.setdefault(key, default)
 
@@ -561,16 +523,16 @@ class LockedDictProxy(dict, Generic[T]):  # type: ignore[type-arg]
     def __contains__(self, key: object) -> bool:
         return key in self._dict
 
-    def keys(self) -> KeysView[str]:  # type: ignore[override]
+    def keys(self) -> KeysView[str]:
         return self._dict.keys()
 
-    def values(self) -> ValuesView[T]:  # type: ignore[override]
+    def values(self) -> ValuesView[T]:
         return self._dict.values()
 
-    def items(self) -> ItemsView[str, T]:  # type: ignore[override]
+    def items(self) -> ItemsView[str, T]:
         return self._dict.items()
 
-    def get(self, key: str, default: T | None = None) -> T | None:  # type: ignore[override]
+    def get(self, key: str, default: T | None = None) -> T | None:
         return self._dict.get(key, default)
 
     def __repr__(self) -> str:
@@ -579,20 +541,6 @@ class LockedDictProxy(dict, Generic[T]):  # type: ignore[type-arg]
     def __bool__(self) -> bool:
         return bool(self._dict)
 
-    def __eq__(self, other: object) -> bool:
-        """Compare based on the underlying dict contents."""
-        if isinstance(other, LockedDictProxy):
-            # Avoid deadlocks by acquiring locks in a consistent order.
-            first, second = (self, other) if id(self) <= id(other) else (other, self)
-            with first._lock:
-                with second._lock:
-                    return first._dict == second._dict
-        with self._lock:
-            return self._dict == other
-
-    def __ne__(self, other: object) -> bool:
-        return not self.__eq__(other)
-
 
 class StateProxy(Generic[T]):
     """Proxy that provides thread-safe access to flow state.
@@ -752,10 +700,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
     name: str | None = None
     tracing: bool | None = None
     stream: bool = False
-    memory: Any = (
-        None  # Memory | MemoryScope | MemorySlice | None; auto-created if not set
-    )
-    input_provider: Any = None  # InputProvider | None; per-flow override for self.ask()
 
     def __class_getitem__(cls: type[Flow[T]], item: type[T]) -> type[Flow[T]]:
         class _FlowGeneric(cls):  # type: ignore
@@ -802,9 +746,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
         self._pending_feedback_context: PendingFeedbackContext | None = None
         self.suppress_flow_events: bool = suppress_flow_events
 
-        # User input history (for self.ask())
-        self._input_history: list[InputHistoryEntry] = []
-
         # Initialize state with initial values
         self._state = self._create_initial_state()
         self.tracing = tracing
@@ -826,14 +767,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 ),
             )
 
-        # Auto-create memory if not provided at class or instance level.
-        # Internal flows (RecallFlow, EncodingFlow) set _skip_auto_memory
-        # to avoid creating a wasteful standalone Memory instance.
-        if self.memory is None and not getattr(self, "_skip_auto_memory", False):
-            from crewai.memory.unified_memory import Memory
-
-            self.memory = Memory()
-
         # Register all flow-related methods
         for method_name in dir(self):
             if not method_name.startswith("_"):
@@ -844,63 +777,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
                         method = method.__get__(self, self.__class__)
                     self._methods[method.__name__] = method
 
-    def recall(self, query: str, **kwargs: Any) -> Any:
-        """Recall relevant memories. Delegates to this flow's memory.
-
-        Args:
-            query: Natural language query.
-            **kwargs: Passed to memory.recall (e.g. scope, categories, limit, depth).
-
-        Returns:
-            Result of memory.recall(query, **kwargs).
-
-        Raises:
-            ValueError: If no memory is configured for this flow.
-        """
-        if self.memory is None:
-            raise ValueError("No memory configured for this flow")
-        return self.memory.recall(query, **kwargs)
-
-    def remember(self, content: str | list[str], **kwargs: Any) -> Any:
-        """Store one or more items in memory.
-
-        Pass a single string for synchronous save (returns the MemoryRecord).
-        Pass a list of strings for non-blocking batch save (returns immediately).
-
-        Args:
-            content: Text or list of texts to remember.
-            **kwargs: Passed to memory.remember / remember_many
-                      (e.g. scope, categories, metadata, importance).
-
-        Returns:
-            MemoryRecord for single item, empty list for batch (background save).
-
-        Raises:
-            ValueError: If no memory is configured for this flow.
-        """
-        if self.memory is None:
-            raise ValueError("No memory configured for this flow")
-        if isinstance(content, list):
-            return self.memory.remember_many(content, **kwargs)
-        return self.memory.remember(content, **kwargs)
-
-    def extract_memories(self, content: str) -> list[str]:
-        """Extract discrete memories from content. Delegates to this flow's memory.
-
-        Args:
-            content: Raw text (e.g. task + result dump).
-
-        Returns:
-            List of short, self-contained memory statements.
-
-        Raises:
-            ValueError: If no memory is configured for this flow.
-        """
-        if self.memory is None:
-            raise ValueError("No memory configured for this flow")
-        result: list[str] = self.memory.extract_memories(content)
-        return result
-
     def _mark_or_listener_fired(self, listener_name: FlowMethodName) -> bool:
         """Mark an OR listener as fired atomically.
 
@@ -1370,10 +1246,8 @@ class Flow(Generic[T], metaclass=FlowMeta):
             ValueError: If structured state model lacks 'id' field
             TypeError: If state is neither BaseModel nor dictionary
         """
-        init_state = self.initial_state
-
         # Handle case where initial_state is None but we have a type parameter
-        if init_state is None and hasattr(self, "_initial_state_t"):
+        if self.initial_state is None and hasattr(self, "_initial_state_t"):
             state_type = self._initial_state_t
             if isinstance(state_type, type):
                 if issubclass(state_type, FlowState):
@@ -1397,12 +1271,12 @@ class Flow(Generic[T], metaclass=FlowMeta):
                     return cast(T, {"id": str(uuid4())})
 
         # Handle case where no initial state is provided
-        if init_state is None:
+        if self.initial_state is None:
             return cast(T, {"id": str(uuid4())})
 
         # Handle case where initial_state is a type (class)
-        if isinstance(init_state, type):
-            state_class = init_state
+        if isinstance(self.initial_state, type):
+            state_class: type[T] = self.initial_state
             if issubclass(state_class, FlowState):
                 return state_class()
             if issubclass(state_class, BaseModel):
@@ -1413,19 +1287,19 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 if not getattr(model_instance, "id", None):
                     object.__setattr__(model_instance, "id", str(uuid4()))
                 return model_instance
-            if init_state is dict:
+            if self.initial_state is dict:
                 return cast(T, {"id": str(uuid4())})
 
         # Handle dictionary instance case
-        if isinstance(init_state, dict):
-            new_state = dict(init_state)  # Copy to avoid mutations
+        if isinstance(self.initial_state, dict):
+            new_state = dict(self.initial_state)  # Copy to avoid mutations
             if "id" not in new_state:
                 new_state["id"] = str(uuid4())
             return cast(T, new_state)
 
         # Handle BaseModel instance case
-        if isinstance(init_state, BaseModel):
-            model = cast(BaseModel, init_state)
+        if isinstance(self.initial_state, BaseModel):
+            model = cast(BaseModel, self.initial_state)
             if not hasattr(model, "id"):
                 raise ValueError("Flow state model must have an 'id' field")
 
@@ -1739,12 +1613,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
         async def _run_flow() -> Any:
             return await self.kickoff_async(inputs, input_files)
 
-        try:
-            asyncio.get_running_loop()
-            with ThreadPoolExecutor(max_workers=1) as pool:
-                return pool.submit(asyncio.run, _run_flow()).result()
-        except RuntimeError:
-            return asyncio.run(_run_flow())
+        return asyncio.run(_run_flow())
 
     async def kickoff_async(
         self,
@@ -1829,13 +1698,8 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 self._pending_and_listeners.clear()
                 self._clear_or_listeners()
             else:
-                # Only enter resumption mode if there are completed methods to
-                # replay.  When _completed_methods is empty (e.g. a pure
-                # state-reload via kickoff(inputs={"id": ...})), the flow
-                # executes from scratch and the flag would incorrectly
-                # suppress cyclic re-execution on the second iteration.
-                if self._completed_methods:
-                    self._is_execution_resuming = True
+                # We're restoring from persistence, set the flag
+                self._is_execution_resuming = True
 
             if inputs:
                 # Override the id in the state if it exists in inputs
@@ -2008,9 +1872,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
 
             return final_output
         finally:
-            # Ensure all background memory saves complete before returning
-            if self.memory is not None and hasattr(self.memory, "drain_writes"):
-                self.memory.drain_writes()
             if request_id_token is not None:
                 current_flow_request_id.reset(request_id_token)
             if flow_id_token is not None:
@@ -2153,24 +2014,15 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 if future:
                     self._event_futures.append(future)
 
-            # Set method name in context so ask() can read it without
-            # stack inspection.  Must happen before copy_context() so the
-            # value propagates into the thread pool for sync methods.
-            from crewai.flow.flow_context import current_flow_method_name
+            if asyncio.iscoroutinefunction(method):
+                result = await method(*args, **kwargs)
+            else:
+                # Run sync methods in thread pool for isolation
+                # This allows Agent.kickoff() to work synchronously inside Flow methods
+                import contextvars
 
-            method_name_token = current_flow_method_name.set(method_name)
-            try:
-                if asyncio.iscoroutinefunction(method):
-                    result = await method(*args, **kwargs)
-                else:
-                    # Run sync methods in thread pool for isolation
-                    # This allows Agent.kickoff() to work synchronously inside Flow methods
-                    import contextvars
-
-                    ctx = contextvars.copy_context()
-                    result = await asyncio.to_thread(ctx.run, method, *args, **kwargs)
-            finally:
-                current_flow_method_name.reset(method_name_token)
+                ctx = contextvars.copy_context()
+                result = await asyncio.to_thread(ctx.run, method, *args, **kwargs)
 
             # Auto-await coroutines returned from sync methods (enables AgentExecutor pattern)
             if asyncio.iscoroutine(result):
@@ -2203,8 +2055,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
             from crewai.flow.async_feedback.types import HumanFeedbackPending
 
             if isinstance(e, HumanFeedbackPending):
-                e.context.method_name = method_name
-
                 # Auto-save pending feedback (create default persistence if needed)
                 if self._persistence is None:
                     from crewai.flow.persistence import SQLiteFlowPersistence
@@ -2304,23 +2154,14 @@ class Flow(Generic[T], metaclass=FlowMeta):
                     router_name, router_input, current_triggering_event_id
                 )
                 if router_result:  # Only add non-None results
-                    router_result_str = (
-                        router_result.value
-                        if isinstance(router_result, enum.Enum)
-                        else str(router_result)
-                    )
-                    router_results.append(FlowMethodName(router_result_str))
+                    router_results.append(FlowMethodName(str(router_result)))
                     # If this was a human_feedback router, map the outcome to the feedback
                     if self.last_human_feedback is not None:
-                        router_result_to_feedback[router_result_str] = (
+                        router_result_to_feedback[str(router_result)] = (
                             self.last_human_feedback
                         )
                 current_trigger = (
-                    FlowMethodName(
-                        router_result.value
-                        if isinstance(router_result, enum.Enum)
-                        else str(router_result)
-                    )
+                    FlowMethodName(str(router_result))
                     if router_result is not None
                     else FlowMethodName("")  # Update for next iteration of router chain
                 )
@@ -2587,12 +2428,8 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 return (None, None)
             # For cyclic flows, clear from completed to allow re-execution
             self._completed_methods.discard(listener_name)
-            # Clear ALL fired OR listeners so they can fire again in the new cycle.
-            # This mirrors what _execute_start_method does for start-method cycles.
-            # Only discarding the individual listener is insufficient because
-            # downstream or_() listeners (e.g., method_a listening to
-            # or_(handler_a, handler_b)) would remain suppressed across iterations.
-            self._clear_or_listeners()
+            # Also clear from fired OR listeners for cyclic flows
+            self._discard_or_listener(listener_name)
 
         try:
             method = self._methods[listener_name]
@@ -2636,206 +2473,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 logger.error(f"Error executing listener {listener_name}: {e}")
             raise
 
-    # ── User Input (self.ask) ────────────────────────────────────────
-
-    def _resolve_input_provider(self) -> Any:
-        """Resolve the input provider using the priority chain.
-
-        Resolution order:
-        1. ``self.input_provider`` (per-flow override)
-        2. ``flow_config.input_provider`` (global default)
-        3. ``ConsoleInputProvider()`` (built-in fallback)
-
-        Returns:
-            An object implementing the ``InputProvider`` protocol.
-        """
-        from crewai.flow.async_feedback.providers import ConsoleProvider
-        from crewai.flow.flow_config import flow_config
-
-        if self.input_provider is not None:
-            return self.input_provider
-        if flow_config.input_provider is not None:
-            return flow_config.input_provider
-        return ConsoleProvider()
-
-    def _checkpoint_state_for_ask(self) -> None:
-        """Auto-checkpoint flow state before waiting for user input.
-
-        If persistence is configured, saves the current state so that
-        ``self.state`` is recoverable even if the process crashes while
-        waiting for input.
-
-        This is best-effort: if persistence is not configured, this is a no-op.
-        """
-        if self._persistence is None:
-            return
-        try:
-            state_data = (
-                self._state
-                if isinstance(self._state, dict)
-                else self._state.model_dump()
-            )
-            self._persistence.save_state(
-                flow_uuid=self.flow_id,
-                method_name="_ask_checkpoint",
-                state_data=state_data,
-            )
-        except Exception:
-            logger.debug("Failed to checkpoint state before ask()", exc_info=True)
-
-    def ask(
-        self,
-        message: str,
-        timeout: float | None = None,
-        metadata: dict[str, Any] | None = None,
-    ) -> str | None:
-        """Request input from the user during flow execution.
-
-        Blocks the current thread until the user provides input or the
-        timeout expires. Works in both sync and async flow methods (the
-        flow framework runs sync methods in a thread pool via
-        ``asyncio.to_thread``, so the event loop stays free).
-
-        Timeout ensures flows always terminate. When timeout expires,
-        ``None`` is returned, enabling the pattern::
-
-            while (msg := self.ask("You: ", timeout=300)) is not None:
-                process(msg)
-
-        Before waiting for input, the current ``self.state`` is automatically
-        checkpointed to persistence (if configured) for durability.
-
-        Args:
-            message: The question or prompt to display to the user.
-            timeout: Maximum seconds to wait for input. ``None`` means
-                wait indefinitely. When timeout expires, returns ``None``.
-                Note: timeout is best-effort for the provider call --
-                ``ask()`` returns ``None`` promptly, but the underlying
-                ``request_input()`` may continue running in a background
-                thread until it completes naturally. Network providers
-                should implement their own internal timeouts.
-            metadata: Optional metadata to send to the input provider,
-                such as user ID, channel, session context. The provider
-                can use this to route the question to the right recipient.
-
-        Returns:
-            The user's input as a string, or ``None`` on timeout, disconnect,
-            or provider error. Empty string ``""`` means the user pressed
-            Enter without typing (intentional empty input).
-
-        Example:
-            ```python
-            class MyFlow(Flow):
-                @start()
-                def gather_info(self):
-                    topic = self.ask(
-                        "What topic should we research?",
-                        metadata={"user_id": "u123", "channel": "#research"},
-                    )
-                    if topic is None:
-                        return "No input received"
-                    return topic
-            ```
-        """
-        from concurrent.futures import (
-            ThreadPoolExecutor,
-            TimeoutError as FuturesTimeoutError,
-        )
-        from datetime import datetime
-
-        from crewai.events.types.flow_events import (
-            FlowInputReceivedEvent,
-            FlowInputRequestedEvent,
-        )
-        from crewai.flow.flow_context import current_flow_method_name
-        from crewai.flow.input_provider import InputResponse
-
-        method_name = current_flow_method_name.get("unknown")
-
-        # Emit input requested event
-        crewai_event_bus.emit(
-            self,
-            FlowInputRequestedEvent(
-                type="flow_input_requested",
-                flow_name=self.name or self.__class__.__name__,
-                method_name=method_name,
-                message=message,
-                metadata=metadata,
-            ),
-        )
-
-        # Auto-checkpoint state before waiting
-        self._checkpoint_state_for_ask()
-
-        provider = self._resolve_input_provider()
-        raw: str | InputResponse | None = None
-
-        try:
-            if timeout is not None:
-                # Manual executor management to avoid shutdown(wait=True)
-                # deadlock when the provider call outlives the timeout.
-                executor = ThreadPoolExecutor(max_workers=1)
-                future = executor.submit(
-                    provider.request_input, message, self, metadata
-                )
-                try:
-                    raw = future.result(timeout=timeout)
-                except FuturesTimeoutError:
-                    future.cancel()
-                    raw = None
-                finally:
-                    # wait=False so we don't block if the provider is still
-                    # running (e.g. input() stuck waiting for user).
-                    # cancel_futures=True cleans up any queued-but-not-started tasks.
-                    executor.shutdown(wait=False, cancel_futures=True)
-            else:
-                raw = provider.request_input(message, self, metadata=metadata)
-        except KeyboardInterrupt:
-            raise
-        except Exception:
-            logger.debug("Input provider error in ask()", exc_info=True)
-            raw = None
-
-        # Normalize provider response: str, InputResponse, or None
-        response: str | None = None
-        response_metadata: dict[str, Any] | None = None
-
-        if isinstance(raw, InputResponse):
-            response = raw.text
-            response_metadata = raw.metadata
-        elif isinstance(raw, str):
-            response = raw
-        else:
-            response = None
-
-        # Record in history
-        self._input_history.append(
-            {
-                "message": message,
-                "response": response,
-                "method_name": method_name,
-                "timestamp": datetime.now(),
-                "metadata": metadata,
-                "response_metadata": response_metadata,
-            }
-        )
-
-        # Emit input received event
-        crewai_event_bus.emit(
-            self,
-            FlowInputReceivedEvent(
-                type="flow_input_received",
-                flow_name=self.name or self.__class__.__name__,
-                method_name=method_name,
-                message=message,
-                response=response,
-                metadata=metadata,
-                response_metadata=response_metadata,
-            ),
-        )
-
-        return response
-
     def _request_human_feedback(
         self,
         message: str,

lib/crewai/src/crewai/flow/flow_config.py

@@ -11,7 +11,6 @@ from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from crewai.flow.async_feedback.types import HumanFeedbackProvider
-    from crewai.flow.input_provider import InputProvider
 
 
 class FlowConfig:
@@ -21,15 +20,10 @@ class FlowConfig:
         hitl_provider: The human-in-the-loop feedback provider.
                        Defaults to None (uses console input).
                        Can be overridden by deployments at startup.
-        input_provider: The input provider used by ``Flow.ask()``.
-                        Defaults to None (uses ``ConsoleProvider``).
-                        Can be overridden by
-                        deployments at startup.
     """
 
     def __init__(self) -> None:
         self._hitl_provider: HumanFeedbackProvider | None = None
-        self._input_provider: InputProvider | None = None
 
     @property
     def hitl_provider(self) -> Any:
@@ -41,32 +35,6 @@ class FlowConfig:
         """Set the HITL provider."""
         self._hitl_provider = provider
 
-    @property
-    def input_provider(self) -> Any:
-        """Get the configured input provider for ``Flow.ask()``.
-
-        Returns:
-            The configured InputProvider instance, or None if not set
-            (in which case ``ConsoleInputProvider`` is used as default).
-        """
-        return self._input_provider
-
-    @input_provider.setter
-    def input_provider(self, provider: Any) -> None:
-        """Set the input provider for ``Flow.ask()``.
-
-        Args:
-            provider: An object implementing the ``InputProvider`` protocol.
-
-        Example:
-            ```python
-            from crewai.flow import flow_config
-
-            flow_config.input_provider = WebSocketInputProvider(...)
-            ```
-        """
-        self._input_provider = provider
-
 
 # Singleton instance
 flow_config = FlowConfig()

lib/crewai/src/crewai/flow/flow_context.py

@@ -14,7 +14,3 @@ current_flow_request_id: contextvars.ContextVar[str | None] = contextvars.Contex
 current_flow_id: contextvars.ContextVar[str | None] = contextvars.ContextVar(
     "flow_id", default=None
 )
-
-current_flow_method_name: contextvars.ContextVar[str] = contextvars.ContextVar(
-    "flow_method_name", default="unknown"
-)

lib/crewai/src/crewai/flow/human_feedback.py

@@ -62,8 +62,6 @@ from datetime import datetime
 from functools import wraps
 from typing import TYPE_CHECKING, Any, TypeVar
 
-from pydantic import BaseModel, Field
-
 from crewai.flow.flow_wrappers import FlowMethod
 
 
@@ -134,12 +132,10 @@ class HumanFeedbackConfig:
 
     message: str
     emit: Sequence[str] | None = None
-    llm: str | BaseLLM | None = "gpt-4o-mini"
+    llm: str | BaseLLM | None = None
     default_outcome: str | None = None
     metadata: dict[str, Any] | None = None
     provider: HumanFeedbackProvider | None = None
-    learn: bool = False
-    learn_source: str = "hitl"
 
 
 class HumanFeedbackMethod(FlowMethod[Any, Any]):
@@ -159,36 +155,13 @@ class HumanFeedbackMethod(FlowMethod[Any, Any]):
     __human_feedback_config__: HumanFeedbackConfig | None = None
 
 
-class PreReviewResult(BaseModel):
-    """Structured output from the HITL pre-review LLM call."""
-
-    improved_output: str = Field(
-        description="The improved version of the output with past human feedback lessons applied.",
-    )
-
-
-class DistilledLessons(BaseModel):
-    """Structured output from the HITL lesson distillation LLM call."""
-
-    lessons: list[str] = Field(
-        default_factory=list,
-        description=(
-            "Generalizable lessons extracted from the human feedback. "
-            "Each lesson should be a reusable rule or preference. "
-            "Return an empty list if the feedback contains no generalizable guidance."
-        ),
-    )
-
-
 def human_feedback(
     message: str,
     emit: Sequence[str] | None = None,
-    llm: str | BaseLLM | None = "gpt-4o-mini",
+    llm: str | BaseLLM | None = None,
     default_outcome: str | None = None,
     metadata: dict[str, Any] | None = None,
     provider: HumanFeedbackProvider | None = None,
-    learn: bool = False,
-    learn_source: str = "hitl"
 ) -> Callable[[F], F]:
     """Decorator for Flow methods that require human feedback.
 
@@ -283,9 +256,7 @@ def human_feedback(
         if not llm:
             raise ValueError(
                 "llm is required when emit is specified. "
-                "Provide an LLM model string (e.g., 'gpt-4o-mini') or a BaseLLM instance. "
-                "See the CrewAI Human-in-the-Loop (HITL) documentation for more information: "
-                "https://docs.crewai.com/en/learn/human-feedback-in-flows"
+                "Provide an LLM model string (e.g., 'gpt-4o-mini') or a BaseLLM instance."
             )
         if default_outcome is not None and default_outcome not in emit:
             raise ValueError(
@@ -298,101 +269,6 @@ def human_feedback(
     def decorator(func: F) -> F:
         """Inner decorator that wraps the function."""
 
-        # -- HITL learning helpers (only used when learn=True) --------
-
-        def _get_hitl_prompt(key: str) -> str:
-            """Read a HITL prompt from the i18n translations."""
-            from crewai.utilities.i18n import get_i18n
-
-            return get_i18n().slice(key)
-
-        def _resolve_llm_instance() -> Any:
-            """Resolve the ``llm`` parameter to a BaseLLM instance.
-
-            Uses the SAME model specified in the decorator so pre-review,
-            distillation, and outcome collapsing all share one model.
-            """
-            if llm is None:
-                from crewai.llm import LLM
-
-                return LLM(model="gpt-4o-mini")
-            if isinstance(llm, str):
-                from crewai.llm import LLM
-
-                return LLM(model=llm)
-            return llm  # already a BaseLLM instance
-
-        def _pre_review_with_lessons(
-            flow_instance: Flow[Any], method_output: Any
-        ) -> Any:
-            """Recall past HITL lessons and use LLM to pre-review the output."""
-            try:
-                query = f"human feedback lessons for {func.__name__}: {method_output!s}"
-                matches = flow_instance.memory.recall(
-                    query, source=learn_source
-                )
-                if not matches:
-                    return method_output
-
-                lessons = "\n".join(f"- {m.record.content}" for m in matches)
-                llm_inst = _resolve_llm_instance()
-                prompt = _get_hitl_prompt("hitl_pre_review_user").format(
-                    output=str(method_output),
-                    lessons=lessons,
-                )
-                messages = [
-                    {"role": "system", "content": _get_hitl_prompt("hitl_pre_review_system")},
-                    {"role": "user", "content": prompt},
-                ]
-                if getattr(llm_inst, "supports_function_calling", lambda: False)():
-                    response = llm_inst.call(messages, response_model=PreReviewResult)
-                    if isinstance(response, PreReviewResult):
-                        return response.improved_output
-                    return PreReviewResult.model_validate(response).improved_output
-                reviewed = llm_inst.call(messages)
-                return reviewed if isinstance(reviewed, str) else str(reviewed)
-            except Exception:
-                return method_output  # fallback to raw output on any failure
-
-        def _distill_and_store_lessons(
-            flow_instance: Flow[Any], method_output: Any, raw_feedback: str
-        ) -> None:
-            """Extract generalizable lessons from output + feedback, store in memory."""
-            try:
-                llm_inst = _resolve_llm_instance()
-                prompt = _get_hitl_prompt("hitl_distill_user").format(
-                    method_name=func.__name__,
-                    output=str(method_output),
-                    feedback=raw_feedback,
-                )
-                messages = [
-                    {"role": "system", "content": _get_hitl_prompt("hitl_distill_system")},
-                    {"role": "user", "content": prompt},
-                ]
-
-                lessons: list[str] = []
-                if getattr(llm_inst, "supports_function_calling", lambda: False)():
-                    response = llm_inst.call(messages, response_model=DistilledLessons)
-                    if isinstance(response, DistilledLessons):
-                        lessons = response.lessons
-                    else:
-                        lessons = DistilledLessons.model_validate(response).lessons
-                else:
-                    response = llm_inst.call(messages)
-                    if isinstance(response, str):
-                        lessons = [
-                            line.strip("- ").strip()
-                            for line in response.strip().split("\n")
-                            if line.strip() and line.strip() != "NONE"
-                        ]
-
-                if lessons:
-                    flow_instance.memory.remember_many(lessons, source=learn_source)
-            except Exception:  # noqa: S110
-                pass  # non-critical: don't fail the flow because lesson storage failed
-
-        # -- Core feedback helpers ------------------------------------
-
         def _request_feedback(flow_instance: Flow[Any], method_output: Any) -> str:
             """Request feedback using provider or default console."""
             from crewai.flow.async_feedback.types import PendingFeedbackContext
@@ -477,40 +353,28 @@ def human_feedback(
             # Async wrapper
             @wraps(func)
             async def async_wrapper(self: Flow[Any], *args: Any, **kwargs: Any) -> Any:
+                # Execute the original method
                 method_output = await func(self, *args, **kwargs)
 
-                # Pre-review: apply past HITL lessons before human sees it
-                if learn and getattr(self, "memory", None) is not None:
-                    method_output = _pre_review_with_lessons(self, method_output)
-
+                # Request human feedback (may raise HumanFeedbackPending)
                 raw_feedback = _request_feedback(self, method_output)
-                result = _process_feedback(self, method_output, raw_feedback)
 
-                # Distill: extract lessons from output + feedback, store in memory
-                if learn and getattr(self, "memory", None) is not None and raw_feedback.strip():
-                    _distill_and_store_lessons(self, method_output, raw_feedback)
-
-                return result
+                # Process and return
+                return _process_feedback(self, method_output, raw_feedback)
 
             wrapper: Any = async_wrapper
         else:
             # Sync wrapper
             @wraps(func)
             def sync_wrapper(self: Flow[Any], *args: Any, **kwargs: Any) -> Any:
+                # Execute the original method
                 method_output = func(self, *args, **kwargs)
 
-                # Pre-review: apply past HITL lessons before human sees it
-                if learn and getattr(self, "memory", None) is not None:
-                    method_output = _pre_review_with_lessons(self, method_output)
-
+                # Request human feedback (may raise HumanFeedbackPending)
                 raw_feedback = _request_feedback(self, method_output)
-                result = _process_feedback(self, method_output, raw_feedback)
 
-                # Distill: extract lessons from output + feedback, store in memory
-                if learn and getattr(self, "memory", None) is not None and raw_feedback.strip():
-                    _distill_and_store_lessons(self, method_output, raw_feedback)
-
-                return result
+                # Process and return
+                return _process_feedback(self, method_output, raw_feedback)
 
             wrapper = sync_wrapper
 
@@ -533,8 +397,6 @@ def human_feedback(
             default_outcome=default_outcome,
             metadata=metadata,
             provider=provider,
-            learn=learn,
-            learn_source=learn_source
         )
         wrapper.__is_flow_method__ = True
 

lib/crewai/src/crewai/flow/input_provider.py

@@ -1,151 +0,0 @@
-"""Input provider protocol for Flow.ask().
-
-This module provides the InputProvider protocol and InputResponse dataclass
-used by Flow.ask() to request input from users during flow execution.
-
-The default implementation is ``ConsoleProvider`` (from
-``crewai.flow.async_feedback.providers``), which serves both feedback
-and input collection via console.
-
-Example (default console input):
-    ```python
-    from crewai.flow import Flow, start
-
-
-    class MyFlow(Flow):
-        @start()
-        def gather_info(self):
-            topic = self.ask("What topic should we research?")
-            return topic
-    ```
-
-Example (custom provider with metadata):
-    ```python
-    from crewai.flow import Flow, start
-    from crewai.flow.input_provider import InputProvider, InputResponse
-
-
-    class SlackProvider:
-        def request_input(self, message, flow, metadata=None):
-            channel = metadata.get("channel", "#general") if metadata else "#general"
-            thread = self.post_question(channel, message)
-            reply = self.wait_for_reply(thread)
-            return InputResponse(
-                text=reply.text,
-                metadata={"responded_by": reply.user_id, "thread_id": thread.id},
-            )
-
-
-    class MyFlow(Flow):
-        input_provider = SlackProvider()
-
-        @start()
-        def gather_info(self):
-            topic = self.ask("What topic?", metadata={"channel": "#research"})
-            return topic
-    ```
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
-
-
-if TYPE_CHECKING:
-    from crewai.flow.flow import Flow
-
-
-@dataclass
-class InputResponse:
-    """Response from an InputProvider, optionally carrying metadata.
-
-    Simple providers can just return a string from ``request_input()``.
-    Providers that need to send metadata back (e.g., who responded,
-    thread ID, external timestamps) return an ``InputResponse`` instead.
-
-    ``ask()`` normalizes both cases -- callers always get ``str | None``.
-    The response metadata is stored in ``_input_history`` and emitted
-    in ``FlowInputReceivedEvent``.
-
-    Attributes:
-        text: The user's input text, or None if unavailable.
-        metadata: Optional metadata from the provider about the response
-            (e.g., who responded, thread ID, timestamps).
-
-    Example:
-        ```python
-        class MyProvider:
-            def request_input(self, message, flow, metadata=None):
-                response = get_response_from_external_system(message)
-                return InputResponse(
-                    text=response.text,
-                    metadata={"responded_by": response.user_id},
-                )
-        ```
-    """
-
-    text: str | None
-    metadata: dict[str, Any] | None = field(default=None)
-
-
-@runtime_checkable
-class InputProvider(Protocol):
-    """Protocol for user input collection strategies.
-
-    Implement this protocol to create custom input providers that integrate
-    with external systems like websockets, web UIs, Slack, or custom APIs.
-
-    The default provider is ``ConsoleProvider``, which blocks waiting for
-    console input via Python's built-in ``input()`` function.
-
-    Providers are always synchronous. The flow framework runs sync methods
-    in a thread pool (via ``asyncio.to_thread``), so ``ask()`` never blocks
-    the event loop even inside async flow methods.
-
-    Providers can return either:
-    - ``str | None`` for simple cases (no response metadata)
-    - ``InputResponse`` when they need to send metadata back with the answer
-
-    Example (simple):
-        ```python
-        class SimpleProvider:
-            def request_input(self, message: str, flow: Flow) -> str | None:
-                return input(message)
-        ```
-
-    Example (with metadata):
-        ```python
-        class SlackProvider:
-            def request_input(self, message, flow, metadata=None):
-                channel = metadata.get("channel") if metadata else "#general"
-                reply = self.post_and_wait(channel, message)
-                return InputResponse(
-                    text=reply.text,
-                    metadata={"responded_by": reply.user_id},
-                )
-        ```
-    """
-
-    def request_input(
-        self,
-        message: str,
-        flow: Flow[Any],
-        metadata: dict[str, Any] | None = None,
-    ) -> str | InputResponse | None:
-        """Request input from the user.
-
-        Args:
-            message: The question or prompt to display to the user.
-            flow: The Flow instance requesting input. Can be used to
-                access flow state, name, or other context.
-            metadata: Optional metadata from the caller, such as user ID,
-                channel, session context, etc. Providers can use this to
-                route the question to the right recipient.
-
-        Returns:
-            The user's input as a string, an ``InputResponse`` with text
-            and optional response metadata, or None if input is unavailable
-            (e.g., user cancelled, connection dropped).
-        """
-        ...

lib/crewai/src/crewai/flow/types.py

@@ -4,7 +4,6 @@ This module contains TypedDict definitions and type aliases used throughout
 the Flow system.
 """
 
-from datetime import datetime
 from typing import (
     Annotated,
     Any,
@@ -102,30 +101,6 @@ class FlowData(TypedDict):
     flow_methods_attributes: list[FlowMethodData]
 
 
-class InputHistoryEntry(TypedDict):
-    """A single entry in the flow's input history from ``self.ask()``.
-
-    Each call to ``Flow.ask()`` appends one entry recording the question,
-    the user's response, which method asked, and any metadata exchanged
-    between the caller and the input provider.
-
-    Attributes:
-        message: The question or prompt that was displayed to the user.
-        response: The user's response, or None on timeout/error.
-        method_name: The flow method that called ``ask()``.
-        timestamp: When the input was received.
-        metadata: Metadata sent with the question (caller to provider).
-        response_metadata: Metadata received with the answer (provider to caller).
-    """
-
-    message: str
-    response: str | None
-    method_name: str
-    timestamp: datetime
-    metadata: dict[str, Any] | None
-    response_metadata: dict[str, Any] | None
-
-
 class FlowExecutionData(TypedDict):
     """Flow execution data.
 

lib/crewai/src/crewai/lite_agent.py

@@ -5,7 +5,6 @@ from collections.abc import Callable
 from functools import wraps
 import inspect
 import json
-import time
 from types import MethodType
 from typing import (
     TYPE_CHECKING,
@@ -50,19 +49,9 @@ from crewai.events.types.agent_events import (
     LiteAgentExecutionStartedEvent,
 )
 from crewai.events.types.logging_events import AgentLogsExecutionEvent
-from crewai.events.types.memory_events import (
-    MemoryRetrievalCompletedEvent,
-    MemoryRetrievalFailedEvent,
-    MemoryRetrievalStartedEvent,
-)
 from crewai.flow.flow_trackable import FlowTrackable
 from crewai.hooks.llm_hooks import get_after_llm_call_hooks, get_before_llm_call_hooks
-from crewai.hooks.types import (
-    AfterLLMCallHookCallable,
-    AfterLLMCallHookType,
-    BeforeLLMCallHookCallable,
-    BeforeLLMCallHookType,
-)
+from crewai.hooks.types import AfterLLMCallHookType, BeforeLLMCallHookType
 from crewai.lite_agent_output import LiteAgentOutput
 from crewai.llm import LLM
 from crewai.llms.base_llm import BaseLLM
@@ -255,10 +244,6 @@ class LiteAgent(FlowTrackable, BaseModel):
         description="A2A (Agent-to-Agent) configuration for delegating tasks to remote agents. "
         "Can be a single A2AConfig/A2AClientConfig/A2AServerConfig, or a list of configurations.",
     )
-    memory: bool | Any | None = Field(
-        default=None,
-        description="If True, use default Memory(). If Memory/MemoryScope/MemorySlice, use it for recall and remember.",
-    )
     tools_results: list[dict[str, Any]] = Field(
         default_factory=list, description="Results of the tools used by the agent."
     )
@@ -275,13 +260,12 @@ class LiteAgent(FlowTrackable, BaseModel):
     _guardrail: GuardrailCallable | None = PrivateAttr(default=None)
     _guardrail_retry_count: int = PrivateAttr(default=0)
     _callbacks: list[TokenCalcHandler] = PrivateAttr(default_factory=list)
-    _before_llm_call_hooks: list[BeforeLLMCallHookType | BeforeLLMCallHookCallable] = (
-        PrivateAttr(default_factory=get_before_llm_call_hooks)
+    _before_llm_call_hooks: list[BeforeLLMCallHookType] = PrivateAttr(
+        default_factory=get_before_llm_call_hooks
     )
-    _after_llm_call_hooks: list[AfterLLMCallHookType | AfterLLMCallHookCallable] = (
-        PrivateAttr(default_factory=get_after_llm_call_hooks)
+    _after_llm_call_hooks: list[AfterLLMCallHookType] = PrivateAttr(
+        default_factory=get_after_llm_call_hooks
     )
-    _memory: Any = PrivateAttr(default=None)
 
     @model_validator(mode="after")
     def emit_deprecation_warning(self) -> Self:
@@ -379,19 +363,6 @@ class LiteAgent(FlowTrackable, BaseModel):
 
         return self
 
-    @model_validator(mode="after")
-    def resolve_memory(self) -> Self:
-        """Resolve memory field to _memory: default Memory() when True, else user instance or None."""
-        if self.memory is True:
-            from crewai.memory.unified_memory import Memory
-
-            object.__setattr__(self, "_memory", Memory())
-        elif self.memory is not None and self.memory is not False:
-            object.__setattr__(self, "_memory", self.memory)
-        else:
-            object.__setattr__(self, "_memory", None)
-        return self
-
     @field_validator("guardrail", mode="before")
     @classmethod
     def validate_guardrail_function(
@@ -445,16 +416,12 @@ class LiteAgent(FlowTrackable, BaseModel):
         return self.role
 
     @property
-    def before_llm_call_hooks(
-        self,
-    ) -> list[BeforeLLMCallHookType | BeforeLLMCallHookCallable]:
+    def before_llm_call_hooks(self) -> list[BeforeLLMCallHookType]:
         """Get the before_llm_call hooks for this agent."""
         return self._before_llm_call_hooks
 
     @property
-    def after_llm_call_hooks(
-        self,
-    ) -> list[AfterLLMCallHookType | AfterLLMCallHookCallable]:
+    def after_llm_call_hooks(self) -> list[AfterLLMCallHookType]:
         """Get the after_llm_call hooks for this agent."""
         return self._after_llm_call_hooks
 
@@ -488,20 +455,6 @@ class LiteAgent(FlowTrackable, BaseModel):
         Returns:
             LiteAgentOutput: The result of the agent execution.
         """
-        # Inject memory tools once if memory is configured (mirrors Agent._prepare_kickoff)
-        if self._memory is not None:
-            from crewai.tools.memory_tools import create_memory_tools
-            from crewai.utilities.string_utils import sanitize_tool_name
-
-            existing_names = {sanitize_tool_name(t.name) for t in self._parsed_tools}
-            memory_tools = [
-                mt
-                for mt in create_memory_tools(self._memory)
-                if sanitize_tool_name(mt.name) not in existing_names
-            ]
-            if memory_tools:
-                self._parsed_tools = self._parsed_tools + parse_tools(memory_tools)
-
         # Create agent info for event emission
         agent_info = {
             "id": self.id,
@@ -521,7 +474,6 @@ class LiteAgent(FlowTrackable, BaseModel):
             self._messages = self._format_messages(
                 messages, response_format=response_format, input_files=input_files
             )
-            self._inject_memory_context()
 
             return self._execute_core(
                 agent_info=agent_info, response_format=response_format
@@ -544,77 +496,6 @@ class LiteAgent(FlowTrackable, BaseModel):
             )
             raise e
 
-    def _get_last_user_content(self) -> str:
-        """Get the last user message content from _messages for recall/input."""
-        for msg in reversed(self._messages):
-            if msg.get("role") == "user":
-                content = msg.get("content")
-                return content if isinstance(content, str) else ""
-        return ""
-
-    def _inject_memory_context(self) -> None:
-        """Recall relevant memories and append to the system message. No-op if _memory is None."""
-        if self._memory is None:
-            return
-        query = self._get_last_user_content()
-        crewai_event_bus.emit(
-            self,
-            event=MemoryRetrievalStartedEvent(
-                task_id=None,
-                source_type="lite_agent",
-            ),
-        )
-        start_time = time.time()
-        memory_block = ""
-        try:
-            matches = self._memory.recall(query, limit=10)
-            if matches:
-                memory_block = "Relevant memories:\n" + "\n".join(
-                    f"- {m.record.content}" for m in matches
-                )
-            if memory_block:
-                formatted = self.i18n.slice("memory").format(memory=memory_block)
-                if self._messages and self._messages[0].get("role") == "system":
-                    existing_content = self._messages[0].get("content", "")
-                    if not isinstance(existing_content, str):
-                        existing_content = ""
-                    self._messages[0]["content"] = existing_content + "\n\n" + formatted
-            crewai_event_bus.emit(
-                self,
-                event=MemoryRetrievalCompletedEvent(
-                    task_id=None,
-                    memory_content=memory_block,
-                    retrieval_time_ms=(time.time() - start_time) * 1000,
-                    source_type="lite_agent",
-                ),
-            )
-        except Exception as e:
-            crewai_event_bus.emit(
-                self,
-                event=MemoryRetrievalFailedEvent(
-                    task_id=None,
-                    source_type="lite_agent",
-                    error=str(e),
-                ),
-            )
-
-    def _save_to_memory(self, output_text: str) -> None:
-        """Extract discrete memories from the run and remember each. No-op if _memory is None or read-only."""
-        if self._memory is None or getattr(self._memory, "_read_only", False):
-            return
-        input_str = self._get_last_user_content() or "User request"
-        try:
-            raw = f"Input: {input_str}\nAgent: {self.role}\nResult: {output_text}"
-            extracted = self._memory.extract_memories(raw)
-            if extracted:
-                self._memory.remember_many(extracted, agent_role=self.role)
-        except Exception as e:
-            if self.verbose:
-                self._printer.print(
-                    content=f"Failed to save to memory: {e}",
-                    color="yellow",
-                )
-
     def _execute_core(
         self, agent_info: dict[str, Any], response_format: type[BaseModel] | None = None
     ) -> LiteAgentOutput:
@@ -629,20 +510,11 @@ class LiteAgent(FlowTrackable, BaseModel):
         )
 
         # Execute the agent using invoke loop
-        active_response_format = response_format or self.response_format
-        agent_finish = self._invoke_loop(response_model=active_response_format)
-        if self._memory is not None:
-            output_text = (
-                agent_finish.output.model_dump_json()
-                if isinstance(agent_finish.output, BaseModel)
-                else agent_finish.output
-            )
-            self._save_to_memory(output_text)
+        agent_finish = self._invoke_loop()
         formatted_result: BaseModel | None = None
 
-        if isinstance(agent_finish.output, BaseModel):
-            formatted_result = agent_finish.output
-        elif active_response_format:
+        active_response_format = response_format or self.response_format
+        if active_response_format:
             try:
                 model_schema = generate_model_description(active_response_format)
                 schema = json.dumps(model_schema, indent=2)
@@ -674,13 +546,8 @@ class LiteAgent(FlowTrackable, BaseModel):
             usage_metrics = self._token_process.get_summary()
 
         # Create output
-        raw_output = (
-            agent_finish.output.model_dump_json()
-            if isinstance(agent_finish.output, BaseModel)
-            else agent_finish.output
-        )
         output = LiteAgentOutput(
-            raw=raw_output,
+            raw=agent_finish.output,
             pydantic=formatted_result,
             agent_role=self.role,
             usage_metrics=usage_metrics.model_dump() if usage_metrics else None,
@@ -857,15 +724,10 @@ class LiteAgent(FlowTrackable, BaseModel):
 
         return formatted_messages
 
-    def _invoke_loop(
-        self, response_model: type[BaseModel] | None = None
-    ) -> AgentFinish:
+    def _invoke_loop(self) -> AgentFinish:
         """
         Run the agent's thought process until it reaches a conclusion or max iterations.
 
-        Args:
-            response_model: Optional Pydantic model for native structured output.
-
         Returns:
             AgentFinish: The final result of the agent execution.
         """
@@ -894,19 +756,12 @@ class LiteAgent(FlowTrackable, BaseModel):
                         printer=self._printer,
                         from_agent=self,
                         executor_context=self,
-                        response_model=response_model,
                         verbose=self.verbose,
                     )
 
                 except Exception as e:
                     raise e
 
-                if isinstance(answer, BaseModel):
-                    formatted_answer = AgentFinish(
-                        thought="", output=answer, text=answer.model_dump_json()
-                    )
-                    break
-
                 formatted_answer = process_llm_response(
                     cast(str, answer), self.use_stop_words
                 )
@@ -932,7 +787,7 @@ class LiteAgent(FlowTrackable, BaseModel):
                     )
 
                 self._append_message(formatted_answer.text, role="assistant")
-            except OutputParserError as e:
+            except OutputParserError as e:  # noqa: PERF203
                 if self.verbose:
                     self._printer.print(
                         content="Failed to parse LLM output. Retrying...",

lib/crewai/src/crewai/llm.py

@@ -419,22 +419,8 @@ class LLM(BaseLLM):
 
         # FALLBACK to LiteLLM
         if not LITELLM_AVAILABLE:
-            native_list = ", ".join(SUPPORTED_NATIVE_PROVIDERS)
-            error_msg = (
-                f"Unable to initialize LLM with model '{model}'. "
-                f"The model did not match any supported native provider "
-                f"({native_list}), and the LiteLLM fallback package is not "
-                f"installed.\n\n"
-                f"To fix this, either:\n"
-                f"  1. Install LiteLLM for broad model support: "
-                f"uv add 'crewai[litellm]'\n"
-                f"or\n"
-                f"pip install litellm\n\n"
-                f"For more details, see: "
-                f"https://docs.crewai.com/en/learn/llm-connections"
-            )
-            logger.error(error_msg)
-            raise ImportError(error_msg) from None
+            logger.error("LiteLLM is not available, falling back to LiteLLM")
+            raise ImportError("Fallback to LiteLLM is not available") from None
 
         instance = object.__new__(cls)
         super(LLM, instance).__init__(model=model, is_litellm=True, **kwargs)

lib/crewai/src/crewai/llms/providers/bedrock/completion.py

@@ -234,7 +234,7 @@ class BedrockCompletion(BaseLLM):
         aws_access_key_id: str | None = None,
         aws_secret_access_key: str | None = None,
         aws_session_token: str | None = None,
-        region_name: str | None = None,
+        region_name: str = "us-east-1",
         temperature: float | None = None,
         max_tokens: int | None = None,
         top_p: float | None = None,
@@ -287,6 +287,15 @@ class BedrockCompletion(BaseLLM):
             **kwargs,
         )
 
+        # Initialize Bedrock client with proper configuration
+        session = Session(
+            aws_access_key_id=aws_access_key_id or os.getenv("AWS_ACCESS_KEY_ID"),
+            aws_secret_access_key=aws_secret_access_key
+            or os.getenv("AWS_SECRET_ACCESS_KEY"),
+            aws_session_token=aws_session_token or os.getenv("AWS_SESSION_TOKEN"),
+            region_name=region_name,
+        )
+
         # Configure client with timeouts and retries following AWS best practices
         config = Config(
             read_timeout=300,
@@ -297,12 +306,8 @@ class BedrockCompletion(BaseLLM):
             tcp_keepalive=True,
         )
 
-        self.region_name = (
-            region_name
-            or os.getenv("AWS_DEFAULT_REGION")
-            or os.getenv("AWS_REGION_NAME")
-            or "us-east-1"
-        )
+        self.client = session.client("bedrock-runtime", config=config)
+        self.region_name = region_name
 
         self.aws_access_key_id = aws_access_key_id or os.getenv("AWS_ACCESS_KEY_ID")
         self.aws_secret_access_key = aws_secret_access_key or os.getenv(
@@ -310,16 +315,6 @@ class BedrockCompletion(BaseLLM):
         )
         self.aws_session_token = aws_session_token or os.getenv("AWS_SESSION_TOKEN")
 
-        # Initialize Bedrock client with proper configuration
-        session = Session(
-            aws_access_key_id=self.aws_access_key_id,
-            aws_secret_access_key=self.aws_secret_access_key,
-            aws_session_token=self.aws_session_token,
-            region_name=self.region_name,
-        )
-
-        self.client = session.client("bedrock-runtime", config=config)
-
         self._async_exit_stack = AsyncExitStack() if AIOBOTOCORE_AVAILABLE else None
         self._async_client_initialized = False
 

lib/crewai/src/crewai/llms/providers/gemini/completion.py

@@ -894,7 +894,7 @@ class GeminiCompletion(BaseLLM):
         content = self._extract_text_from_response(response)
 
         effective_response_model = None if self.tools else response_model
-        if not response_model:
+        if not effective_response_model:
             content = self._apply_stop_words(content)
 
         return self._finalize_completion_response(

lib/crewai/src/crewai/mcp/__init__.py

@@ -18,7 +18,6 @@ from crewai.mcp.filters import (
     create_dynamic_tool_filter,
     create_static_tool_filter,
 )
-from crewai.mcp.tool_resolver import MCPToolResolver
 from crewai.mcp.transports.base import BaseTransport, TransportType
 
 
@@ -29,7 +28,6 @@ __all__ = [
     "MCPServerHTTP",
     "MCPServerSSE",
     "MCPServerStdio",
-    "MCPToolResolver",
     "StaticToolFilter",
     "ToolFilter",
     "ToolFilterContext",

lib/crewai/src/crewai/mcp/client.py

@@ -6,7 +6,7 @@ from contextlib import AsyncExitStack
 from datetime import datetime
 import logging
 import time
-from typing import Any, NamedTuple
+from typing import Any
 
 from typing_extensions import Self
 
@@ -34,13 +34,6 @@ from crewai.mcp.transports.stdio import StdioTransport
 from crewai.utilities.string_utils import sanitize_tool_name
 
 
-class _MCPToolResult(NamedTuple):
-    """Internal result from an MCP tool call, carrying the ``isError`` flag."""
-
-    content: str
-    is_error: bool
-
-
 # MCP Connection timeout constants (in seconds)
 MCP_CONNECTION_TIMEOUT = 30  # Increased for slow servers
 MCP_TOOL_EXECUTION_TIMEOUT = 30
@@ -427,7 +420,6 @@ class MCPClient:
         return [
             {
                 "name": sanitize_tool_name(tool.name),
-                "original_name": tool.name,
                 "description": getattr(tool, "description", ""),
                 "inputSchema": getattr(tool, "inputSchema", {}),
             }
@@ -469,46 +461,29 @@ class MCPClient:
         )
 
         try:
-            tool_result: _MCPToolResult = await self._retry_operation(
+            result = await self._retry_operation(
                 lambda: self._call_tool_impl(tool_name, cleaned_arguments),
                 timeout=self.execution_timeout,
             )
 
-            finished_at = datetime.now()
-            execution_duration_ms = (finished_at - started_at).total_seconds() * 1000
+            completed_at = datetime.now()
+            execution_duration_ms = (completed_at - started_at).total_seconds() * 1000
+            crewai_event_bus.emit(
+                self,
+                MCPToolExecutionCompletedEvent(
+                    server_name=server_name,
+                    server_url=server_url,
+                    transport_type=transport_type,
+                    tool_name=tool_name,
+                    tool_args=cleaned_arguments,
+                    result=result,
+                    started_at=started_at,
+                    completed_at=completed_at,
+                    execution_duration_ms=execution_duration_ms,
+                ),
+            )
 
-            if tool_result.is_error:
-                crewai_event_bus.emit(
-                    self,
-                    MCPToolExecutionFailedEvent(
-                        server_name=server_name,
-                        server_url=server_url,
-                        transport_type=transport_type,
-                        tool_name=tool_name,
-                        tool_args=cleaned_arguments,
-                        error=tool_result.content,
-                        error_type="tool_error",
-                        started_at=started_at,
-                        failed_at=finished_at,
-                    ),
-                )
-            else:
-                crewai_event_bus.emit(
-                    self,
-                    MCPToolExecutionCompletedEvent(
-                        server_name=server_name,
-                        server_url=server_url,
-                        transport_type=transport_type,
-                        tool_name=tool_name,
-                        tool_args=cleaned_arguments,
-                        result=tool_result.content,
-                        started_at=started_at,
-                        completed_at=finished_at,
-                        execution_duration_ms=execution_duration_ms,
-                    ),
-                )
-
-            return tool_result.content
+            return result
         except Exception as e:
             failed_at = datetime.now()
             error_type = (
@@ -589,27 +564,23 @@ class MCPClient:
 
         return cleaned
 
-    async def _call_tool_impl(
-        self, tool_name: str, arguments: dict[str, Any]
-    ) -> _MCPToolResult:
+    async def _call_tool_impl(self, tool_name: str, arguments: dict[str, Any]) -> Any:
         """Internal implementation of call_tool."""
         result = await asyncio.wait_for(
             self.session.call_tool(tool_name, arguments),
             timeout=self.execution_timeout,
         )
 
-        is_error = getattr(result, "isError", False) or False
-
         # Extract result content
         if hasattr(result, "content") and result.content:
             if isinstance(result.content, list) and len(result.content) > 0:
                 content_item = result.content[0]
                 if hasattr(content_item, "text"):
-                    return _MCPToolResult(str(content_item.text), is_error)
-                return _MCPToolResult(str(content_item), is_error)
-            return _MCPToolResult(str(result.content), is_error)
+                    return str(content_item.text)
+                return str(content_item)
+            return str(result.content)
 
-        return _MCPToolResult(str(result), is_error)
+        return str(result)
 
     async def list_prompts(self) -> list[dict[str, Any]]:
         """List available prompts from MCP server.

lib/crewai/src/crewai/mcp/tool_resolver.py

@@ -1,592 +0,0 @@
-"""MCP tool resolution for CrewAI agents.
-
-This module extracts all MCP-related tool resolution logic from the Agent class
-into a standalone MCPToolResolver. It handles three flavours of MCP reference:
-
-  1. Native configs:   MCPServerStdio / MCPServerHTTP / MCPServerSSE objects.
-  2. HTTPS URLs:       e.g. "https://mcp.example.com/api"
-  3. AMP references:   e.g. "notion" or "notion#search" (legacy "crewai-amp:" prefix also works)
-"""
-
-from __future__ import annotations
-
-import asyncio
-import time
-from typing import TYPE_CHECKING, Any, Final, cast
-from urllib.parse import urlparse
-
-from crewai.mcp.client import MCPClient
-from crewai.mcp.config import (
-    MCPServerConfig,
-    MCPServerHTTP,
-    MCPServerSSE,
-    MCPServerStdio,
-)
-from crewai.mcp.transports.http import HTTPTransport
-from crewai.mcp.transports.sse import SSETransport
-from crewai.mcp.transports.stdio import StdioTransport
-
-
-if TYPE_CHECKING:
-    from crewai.tools.base_tool import BaseTool
-    from crewai.utilities.logger import Logger
-
-MCP_CONNECTION_TIMEOUT: Final[int] = 10
-MCP_TOOL_EXECUTION_TIMEOUT: Final[int] = 30
-MCP_DISCOVERY_TIMEOUT: Final[int] = 15
-MCP_MAX_RETRIES: Final[int] = 3
-
-_mcp_schema_cache: dict[str, Any] = {}
-_cache_ttl: Final[int] = 300  # 5 minutes
-
-
-class MCPToolResolver:
-    """Resolves MCP server references / configs into CrewAI ``BaseTool`` instances.
-
-    Typical lifecycle::
-
-        resolver = MCPToolResolver(agent=my_agent, logger=my_agent._logger)
-        tools = resolver.resolve(my_agent.mcps)
-        # … agent executes tasks using *tools* …
-        resolver.cleanup()
-
-    The resolver owns the MCP client connections it creates and is responsible
-    for tearing them down via :meth:`cleanup`.
-    """
-
-    def __init__(self, agent: Any, logger: Logger) -> None:
-        self._agent = agent
-        self._logger = logger
-        self._clients: list[Any] = []
-
-    @property
-    def clients(self) -> list[Any]:
-        return list(self._clients)
-
-    def resolve(self, mcps: list[str | MCPServerConfig]) -> list[BaseTool]:
-        """Convert MCP server references/configs to CrewAI tools."""
-        all_tools: list[BaseTool] = []
-        amp_refs: list[tuple[str, str | None]] = []
-
-        for mcp_config in mcps:
-            if isinstance(mcp_config, str) and mcp_config.startswith("https://"):
-                all_tools.extend(self._resolve_external(mcp_config))
-            elif isinstance(mcp_config, str):
-                amp_refs.append(self._parse_amp_ref(mcp_config))
-            else:
-                tools, client = self._resolve_native(mcp_config)
-                all_tools.extend(tools)
-                if client:
-                    self._clients.append(client)
-
-        if amp_refs:
-            tools, clients = self._resolve_amp(amp_refs)
-            all_tools.extend(tools)
-            self._clients.extend(clients)
-
-        return all_tools
-
-    def cleanup(self) -> None:
-        """Disconnect all MCP client connections."""
-        if not self._clients:
-            return
-
-        async def _disconnect_all() -> None:
-            for client in self._clients:
-                if client and hasattr(client, "connected") and client.connected:
-                    await client.disconnect()
-
-        try:
-            asyncio.run(_disconnect_all())
-        except Exception as e:
-            self._logger.log("error", f"Error during MCP client cleanup: {e}")
-        finally:
-            self._clients.clear()
-
-    @staticmethod
-    def _parse_amp_ref(mcp_config: str) -> tuple[str, str | None]:
-        """Parse an AMP reference into *(slug, optional tool name)*.
-
-        Accepts both bare slugs (``"notion"``, ``"notion#search"``) and the
-        legacy ``"crewai-amp:notion"`` form.
-        """
-        bare = mcp_config.removeprefix("crewai-amp:")
-        slug, _, specific_tool = bare.partition("#")
-        return slug, specific_tool or None
-
-    def _resolve_amp(
-        self, amp_refs: list[tuple[str, str | None]]
-    ) -> tuple[list[BaseTool], list[Any]]:
-        """Fetch AMP configs in bulk and return their tools and clients.
-
-        Resolves each unique slug only once (single connection per server),
-        then applies per-ref tool filters to select specific tools.
-        """
-        from crewai.events.event_bus import crewai_event_bus
-        from crewai.events.types.mcp_events import MCPConfigFetchFailedEvent
-
-        unique_slugs = list(dict.fromkeys(slug for slug, _ in amp_refs))
-        amp_configs_map = self._fetch_amp_mcp_configs(unique_slugs)
-
-        all_tools: list[BaseTool] = []
-        all_clients: list[Any] = []
-
-        resolved_cache: dict[str, tuple[list[BaseTool], Any | None]] = {}
-
-        for slug in unique_slugs:
-            config_dict = amp_configs_map.get(slug)
-            if not config_dict:
-                crewai_event_bus.emit(
-                    self,
-                    MCPConfigFetchFailedEvent(
-                        slug=slug,
-                        error=f"Config for '{slug}' not found. Make sure it is connected in your account.",
-                        error_type="not_connected",
-                    ),
-                )
-                continue
-
-            mcp_server_config = self._build_mcp_config_from_dict(config_dict)
-
-            try:
-                tools, client = self._resolve_native(mcp_server_config)
-                resolved_cache[slug] = (tools, client)
-                if client:
-                    all_clients.append(client)
-            except Exception as e:
-                crewai_event_bus.emit(
-                    self,
-                    MCPConfigFetchFailedEvent(
-                        slug=slug,
-                        error=str(e),
-                        error_type="connection_failed",
-                    ),
-                )
-
-        for slug, specific_tool in amp_refs:
-            cached = resolved_cache.get(slug)
-            if not cached:
-                continue
-
-            slug_tools, _ = cached
-            if specific_tool:
-                all_tools.extend(
-                    t for t in slug_tools if t.name.endswith(f"_{specific_tool}")
-                )
-            else:
-                all_tools.extend(slug_tools)
-
-        return all_tools, all_clients
-
-    def _fetch_amp_mcp_configs(self, slugs: list[str]) -> dict[str, dict[str, Any]]:
-        """Fetch MCP server configurations via CrewAI+ API.
-
-        Sends a GET request to the CrewAI+ mcps/configs endpoint with
-        comma-separated slugs. CrewAI+ proxies the request to crewai-oauth.
-
-        API-level failures return ``{}``; individual slugs will then
-        surface as ``MCPConfigFetchFailedEvent`` in :meth:`_resolve_amp`.
-        """
-        import httpx
-
-        try:
-            from crewai_tools.tools.crewai_platform_tools.misc import (
-                get_platform_integration_token,
-            )
-
-            from crewai.cli.plus_api import PlusAPI
-
-            plus_api = PlusAPI(api_key=get_platform_integration_token())
-            response = plus_api.get_mcp_configs(slugs)
-
-            if response.status_code == 200:
-                configs: dict[str, dict[str, Any]] = response.json().get("configs", {})
-                return configs
-
-            self._logger.log(
-                "debug",
-                f"Failed to fetch MCP configs: HTTP {response.status_code}",
-            )
-            return {}
-
-        except httpx.HTTPError as e:
-            self._logger.log("debug", f"Failed to fetch MCP configs: {e}")
-            return {}
-        except Exception as e:
-            self._logger.log("debug", f"Cannot fetch AMP MCP configs: {e}")
-            return {}
-
-    def _resolve_external(self, mcp_ref: str) -> list[BaseTool]:
-        """Resolve an HTTPS MCP server URL into tools."""
-        from crewai.tools.mcp_tool_wrapper import MCPToolWrapper
-
-        if "#" in mcp_ref:
-            server_url, specific_tool = mcp_ref.split("#", 1)
-        else:
-            server_url, specific_tool = mcp_ref, None
-
-        server_params = {"url": server_url}
-        server_name = self._extract_server_name(server_url)
-
-        try:
-            tool_schemas = self._get_mcp_tool_schemas(server_params)
-
-            if not tool_schemas:
-                self._logger.log(
-                    "warning", f"No tools discovered from MCP server: {server_url}"
-                )
-                return []
-
-            tools = []
-            for tool_name, schema in tool_schemas.items():
-                if specific_tool and tool_name != specific_tool:
-                    continue
-
-                try:
-                    wrapper = MCPToolWrapper(
-                        mcp_server_params=server_params,
-                        tool_name=tool_name,
-                        tool_schema=schema,
-                        server_name=server_name,
-                    )
-                    tools.append(wrapper)
-                except Exception as e:
-                    self._logger.log(
-                        "warning",
-                        f"Failed to create MCP tool wrapper for {tool_name}: {e}",
-                    )
-                    continue
-
-            if specific_tool and not tools:
-                self._logger.log(
-                    "warning",
-                    f"Specific tool '{specific_tool}' not found on MCP server: {server_url}",
-                )
-
-            return cast(list[BaseTool], tools)
-
-        except Exception as e:
-            self._logger.log(
-                "warning", f"Failed to connect to MCP server {server_url}: {e}"
-            )
-            return []
-
-    def _resolve_native(
-        self, mcp_config: MCPServerConfig
-    ) -> tuple[list[BaseTool], Any | None]:
-        """Resolve an ``MCPServerConfig`` into tools, returning the client for cleanup."""
-        from crewai.tools.base_tool import BaseTool
-        from crewai.tools.mcp_native_tool import MCPNativeTool
-
-        transport: StdioTransport | HTTPTransport | SSETransport
-        if isinstance(mcp_config, MCPServerStdio):
-            transport = StdioTransport(
-                command=mcp_config.command,
-                args=mcp_config.args,
-                env=mcp_config.env,
-            )
-            server_name = f"{mcp_config.command}_{'_'.join(mcp_config.args)}"
-        elif isinstance(mcp_config, MCPServerHTTP):
-            transport = HTTPTransport(
-                url=mcp_config.url,
-                headers=mcp_config.headers,
-                streamable=mcp_config.streamable,
-            )
-            server_name = self._extract_server_name(mcp_config.url)
-        elif isinstance(mcp_config, MCPServerSSE):
-            transport = SSETransport(
-                url=mcp_config.url,
-                headers=mcp_config.headers,
-            )
-            server_name = self._extract_server_name(mcp_config.url)
-        else:
-            raise ValueError(f"Unsupported MCP server config type: {type(mcp_config)}")
-
-        client = MCPClient(
-            transport=transport,
-            cache_tools_list=mcp_config.cache_tools_list,
-        )
-
-        async def _setup_client_and_list_tools() -> list[dict[str, Any]]:
-            try:
-                if not client.connected:
-                    await client.connect()
-
-                tools_list = await client.list_tools()
-
-                try:
-                    await client.disconnect()
-                    await asyncio.sleep(0.1)
-                except Exception as e:
-                    self._logger.log("error", f"Error during disconnect: {e}")
-
-                return tools_list
-            except Exception as e:
-                if client.connected:
-                    await client.disconnect()
-                    await asyncio.sleep(0.1)
-                raise RuntimeError(
-                    f"Error during setup client and list tools: {e}"
-                ) from e
-
-        try:
-            try:
-                asyncio.get_running_loop()
-                import concurrent.futures
-
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(
-                        asyncio.run, _setup_client_and_list_tools()
-                    )
-                    tools_list = future.result()
-            except RuntimeError:
-                try:
-                    tools_list = asyncio.run(_setup_client_and_list_tools())
-                except RuntimeError as e:
-                    error_msg = str(e).lower()
-                    if "cancel scope" in error_msg or "task" in error_msg:
-                        raise ConnectionError(
-                            "MCP connection failed due to event loop cleanup issues. "
-                            "This may be due to authentication errors or server unavailability."
-                        ) from e
-                except asyncio.CancelledError as e:
-                    raise ConnectionError(
-                        "MCP connection was cancelled. This may indicate an authentication "
-                        "error or server unavailability."
-                    ) from e
-
-            if mcp_config.tool_filter:
-                filtered_tools = []
-                for tool in tools_list:
-                    if callable(mcp_config.tool_filter):
-                        try:
-                            from crewai.mcp.filters import ToolFilterContext
-
-                            context = ToolFilterContext(
-                                agent=self._agent,
-                                server_name=server_name,
-                                run_context=None,
-                            )
-                            if mcp_config.tool_filter(context, tool):  # type: ignore[call-arg, arg-type]
-                                filtered_tools.append(tool)
-                        except (TypeError, AttributeError):
-                            if mcp_config.tool_filter(tool):  # type: ignore[call-arg, arg-type]
-                                filtered_tools.append(tool)
-                    else:
-                        filtered_tools.append(tool)
-                tools_list = filtered_tools
-
-            tools = []
-            for tool_def in tools_list:
-                tool_name = tool_def.get("name", "")
-                original_tool_name = tool_def.get("original_name", tool_name)
-                if not tool_name:
-                    continue
-
-                args_schema = None
-                if tool_def.get("inputSchema"):
-                    args_schema = self._json_schema_to_pydantic(
-                        tool_name, tool_def["inputSchema"]
-                    )
-
-                tool_schema = {
-                    "description": tool_def.get("description", ""),
-                    "args_schema": args_schema,
-                }
-
-                try:
-                    native_tool = MCPNativeTool(
-                        mcp_client=client,
-                        tool_name=tool_name,
-                        tool_schema=tool_schema,
-                        server_name=server_name,
-                        original_tool_name=original_tool_name,
-                    )
-                    tools.append(native_tool)
-                except Exception as e:
-                    self._logger.log("error", f"Failed to create native MCP tool: {e}")
-                    continue
-
-            return cast(list[BaseTool], tools), client
-        except Exception as e:
-            if client.connected:
-                asyncio.run(client.disconnect())
-
-            raise RuntimeError(f"Failed to get native MCP tools: {e}") from e
-
-    @staticmethod
-    def _build_mcp_config_from_dict(
-        config_dict: dict[str, Any],
-    ) -> MCPServerConfig:
-        """Convert a config dict from crewai-oauth into an MCPServerConfig."""
-        config_type = config_dict.get("type", "http")
-
-        if config_type == "sse":
-            return MCPServerSSE(
-                url=config_dict["url"],
-                headers=config_dict.get("headers"),
-                cache_tools_list=config_dict.get("cache_tools_list", False),
-            )
-
-        return MCPServerHTTP(
-            url=config_dict["url"],
-            headers=config_dict.get("headers"),
-            streamable=config_dict.get("streamable", True),
-            cache_tools_list=config_dict.get("cache_tools_list", False),
-        )
-
-    @staticmethod
-    def _extract_server_name(server_url: str) -> str:
-        """Extract clean server name from URL for tool prefixing."""
-        parsed = urlparse(server_url)
-        domain = parsed.netloc.replace(".", "_")
-        path = parsed.path.replace("/", "_").strip("_")
-        return f"{domain}_{path}" if path else domain
-
-    def _get_mcp_tool_schemas(
-        self, server_params: dict[str, Any]
-    ) -> dict[str, dict[str, Any]]:
-        """Get tool schemas from MCP server with caching."""
-        server_url = server_params["url"]
-
-        cache_key = server_url
-        current_time = time.time()
-
-        if cache_key in _mcp_schema_cache:
-            cached_data, cache_time = _mcp_schema_cache[cache_key]
-            if current_time - cache_time < _cache_ttl:
-                self._logger.log(
-                    "debug", f"Using cached MCP tool schemas for {server_url}"
-                )
-                return cached_data  # type: ignore[no-any-return]
-
-        try:
-            schemas = asyncio.run(self._get_mcp_tool_schemas_async(server_params))
-            _mcp_schema_cache[cache_key] = (schemas, current_time)
-            return schemas
-        except Exception as e:
-            self._logger.log(
-                "warning", f"Failed to get MCP tool schemas from {server_url}: {e}"
-            )
-            return {}
-
-    async def _get_mcp_tool_schemas_async(
-        self, server_params: dict[str, Any]
-    ) -> dict[str, dict[str, Any]]:
-        """Async implementation of MCP tool schema retrieval."""
-        server_url = server_params["url"]
-        return await self._retry_mcp_discovery(
-            self._discover_mcp_tools_with_timeout, server_url
-        )
-
-    async def _retry_mcp_discovery(
-        self, operation_func: Any, server_url: str
-    ) -> dict[str, dict[str, Any]]:
-        """Retry MCP discovery with exponential backoff."""
-        last_error = None
-
-        for attempt in range(MCP_MAX_RETRIES):
-            result, error, should_retry = await self._attempt_mcp_discovery(
-                operation_func, server_url
-            )
-
-            if result is not None:
-                return result
-
-            if not should_retry:
-                raise RuntimeError(error)
-
-            last_error = error
-            if attempt < MCP_MAX_RETRIES - 1:
-                wait_time = 2**attempt
-                await asyncio.sleep(wait_time)
-
-        raise RuntimeError(
-            f"Failed to discover MCP tools after {MCP_MAX_RETRIES} attempts: {last_error}"
-        )
-
-    @staticmethod
-    async def _attempt_mcp_discovery(
-        operation_func: Any, server_url: str
-    ) -> tuple[dict[str, dict[str, Any]] | None, str, bool]:
-        """Attempt single MCP discovery; returns *(result, error_message, should_retry)*."""
-        try:
-            result = await operation_func(server_url)
-            return result, "", False
-
-        except ImportError:
-            return (
-                None,
-                "MCP library not available. Please install with: pip install mcp",
-                False,
-            )
-
-        except asyncio.TimeoutError:
-            return (
-                None,
-                f"MCP discovery timed out after {MCP_DISCOVERY_TIMEOUT} seconds",
-                True,
-            )
-
-        except Exception as e:
-            error_str = str(e).lower()
-
-            if "authentication" in error_str or "unauthorized" in error_str:
-                return None, f"Authentication failed for MCP server: {e!s}", False
-            if "connection" in error_str or "network" in error_str:
-                return None, f"Network connection failed: {e!s}", True
-            if "json" in error_str or "parsing" in error_str:
-                return None, f"Server response parsing error: {e!s}", True
-            return None, f"MCP discovery error: {e!s}", False
-
-    async def _discover_mcp_tools_with_timeout(
-        self, server_url: str
-    ) -> dict[str, dict[str, Any]]:
-        """Discover MCP tools with timeout wrapper."""
-        return await asyncio.wait_for(
-            self._discover_mcp_tools(server_url), timeout=MCP_DISCOVERY_TIMEOUT
-        )
-
-    async def _discover_mcp_tools(self, server_url: str) -> dict[str, dict[str, Any]]:
-        """Discover tools from an MCP server (HTTPS / streamable-HTTP path)."""
-        from mcp import ClientSession
-        from mcp.client.streamable_http import streamablehttp_client
-
-        from crewai.utilities.string_utils import sanitize_tool_name
-
-        async with streamablehttp_client(server_url) as (read, write, _):
-            async with ClientSession(read, write) as session:
-                await asyncio.wait_for(
-                    session.initialize(), timeout=MCP_CONNECTION_TIMEOUT
-                )
-
-                tools_result = await asyncio.wait_for(
-                    session.list_tools(),
-                    timeout=MCP_DISCOVERY_TIMEOUT - MCP_CONNECTION_TIMEOUT,
-                )
-
-                schemas = {}
-                for tool in tools_result.tools:
-                    args_schema = None
-                    if hasattr(tool, "inputSchema") and tool.inputSchema:
-                        args_schema = self._json_schema_to_pydantic(
-                            sanitize_tool_name(tool.name), tool.inputSchema
-                        )
-
-                    schemas[sanitize_tool_name(tool.name)] = {
-                        "description": getattr(tool, "description", ""),
-                        "args_schema": args_schema,
-                    }
-                return schemas
-
-    @staticmethod
-    def _json_schema_to_pydantic(tool_name: str, json_schema: dict[str, Any]) -> type:
-        """Convert JSON Schema to a Pydantic model for tool arguments."""
-        from crewai.utilities.pydantic_schema_utils import create_model_from_schema
-
-        model_name = f"{tool_name.replace('-', '_').replace(' ', '_')}Schema"
-        return create_model_from_schema(
-            json_schema,
-            model_name=model_name,
-            enrich_descriptions=True,
-        )

lib/crewai/src/crewai/memory/__init__.py

@@ -1,52 +1,13 @@
-"""Memory module: unified Memory with LLM analysis and pluggable storage.
+from crewai.memory.entity.entity_memory import EntityMemory
+from crewai.memory.external.external_memory import ExternalMemory
+from crewai.memory.long_term.long_term_memory import LongTermMemory
+from crewai.memory.short_term.short_term_memory import ShortTermMemory
 
-Heavy dependencies are lazily imported so that
-``import crewai`` does not initialise at runtime — critical for
-Celery pre-fork and similar deployment patterns.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from crewai.memory.memory_scope import MemoryScope, MemorySlice
-from crewai.memory.types import (
-    MemoryMatch,
-    MemoryRecord,
-    ScopeInfo,
-    compute_composite_score,
-    embed_text,
-    embed_texts,
-)
-
-_LAZY_IMPORTS: dict[str, tuple[str, str]] = {
-    "Memory": ("crewai.memory.unified_memory", "Memory"),
-    "EncodingFlow": ("crewai.memory.encoding_flow", "EncodingFlow"),
-}
-
-
-def __getattr__(name: str) -> Any:
-    """Lazily import Memory / EncodingFlow to avoid pulling in lancedb at import time."""
-    if name in _LAZY_IMPORTS:
-        import importlib
-
-        module_path, attr = _LAZY_IMPORTS[name]
-        mod = importlib.import_module(module_path)
-        val = getattr(mod, attr)
-        globals()[name] = val
-        return val
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 
 __all__ = [
-    "EncodingFlow",
-    "Memory",
-    "MemoryMatch",
-    "MemoryRecord",
-    "MemoryScope",
-    "MemorySlice",
-    "ScopeInfo",
-    "compute_composite_score",
-    "embed_text",
-    "embed_texts",
+    "EntityMemory",
+    "ExternalMemory",
+    "LongTermMemory",
+    "ShortTermMemory",
 ]

lib/crewai/src/crewai/memory/analyze.py

@@ -1,371 +0,0 @@
-"""LLM-powered analysis for memory save and recall."""
-
-from __future__ import annotations
-
-import json
-import logging
-from typing import Any
-
-from pydantic import BaseModel, ConfigDict, Field
-
-from crewai.memory.types import MemoryRecord, ScopeInfo
-from crewai.utilities.i18n import get_i18n
-
-
-_logger = logging.getLogger(__name__)
-
-
-class ExtractedMetadata(BaseModel):
-    """Fixed schema for LLM-extracted metadata (OpenAI requires additionalProperties: false)."""
-
-    model_config = ConfigDict(extra="forbid")
-
-    entities: list[str] = Field(
-        default_factory=list,
-        description="Entities (people, orgs, places) mentioned in the content.",
-    )
-    dates: list[str] = Field(
-        default_factory=list,
-        description="Dates or time references in the content.",
-    )
-    topics: list[str] = Field(
-        default_factory=list,
-        description="Topics or themes in the content.",
-    )
-
-
-class MemoryAnalysis(BaseModel):
-    """LLM output for analyzing content before saving to memory."""
-
-    suggested_scope: str = Field(
-        description="Best matching existing scope or new path (e.g. /company/decisions).",
-    )
-    categories: list[str] = Field(
-        default_factory=list,
-        description="Categories for the memory (prefer existing, add new if needed).",
-    )
-    importance: float = Field(
-        default=0.5,
-        ge=0.0,
-        le=1.0,
-        description="Importance score from 0.0 to 1.0.",
-    )
-    extracted_metadata: ExtractedMetadata = Field(
-        default_factory=ExtractedMetadata,
-        description="Entities, dates, topics extracted from the content.",
-    )
-
-
-class QueryAnalysis(BaseModel):
-    """LLM output for analyzing a recall query."""
-
-    keywords: list[str] = Field(
-        default_factory=list,
-        description="Key entities or keywords for filtering.",
-    )
-    suggested_scopes: list[str] = Field(
-        default_factory=list,
-        description="Scope paths to search (subset of available scopes).",
-    )
-    complexity: str = Field(
-        default="simple",
-        description="One of 'simple' (single fact) or 'complex' (aggregation/reasoning).",
-    )
-    recall_queries: list[str] = Field(
-        default_factory=list,
-        description=(
-            "1-3 short, targeted search phrases distilled from the query. "
-            "Each should be a concise question or keyword phrase optimized "
-            "for semantic vector search. If the query is already short and "
-            "focused, return it as a single item."
-        ),
-    )
-    time_filter: str | None = Field(
-        default=None,
-        description=(
-            "If the query references a specific time period (e.g. 'last week', "
-            "'yesterday', 'in January'), return an ISO 8601 date string representing "
-            "the earliest date that results should match (e.g. '2026-02-01'). "
-            "Return null if no time constraint is implied."
-        ),
-    )
-
-
-class ExtractedMemories(BaseModel):
-    """LLM output for extracting discrete memories from raw content."""
-
-    memories: list[str] = Field(
-        default_factory=list,
-        description="List of discrete, self-contained memory statements extracted from the content.",
-    )
-
-
-class ConsolidationAction(BaseModel):
-    """A single action in a consolidation plan."""
-
-    model_config = ConfigDict(extra="forbid")
-
-    action: str = Field(
-        description="One of 'keep', 'update', or 'delete'.",
-    )
-    record_id: str = Field(
-        description="ID of the existing record this action applies to.",
-    )
-    new_content: str | None = Field(
-        default=None,
-        description="Updated content text. Required when action is 'update'.",
-    )
-    reason: str = Field(
-        default="",
-        description="Brief reason for this action.",
-    )
-
-
-class ConsolidationPlan(BaseModel):
-    """LLM output for consolidating new content with existing memories."""
-
-    model_config = ConfigDict(extra="forbid")
-
-    actions: list[ConsolidationAction] = Field(
-        default_factory=list,
-        description="Actions to take on existing records (keep/update/delete).",
-    )
-    insert_new: bool = Field(
-        default=True,
-        description="Whether to also insert the new content as a separate record.",
-    )
-    insert_reason: str = Field(
-        default="",
-        description="Why the new content should or should not be inserted.",
-    )
-
-
-def _get_prompt(key: str) -> str:
-    """Retrieve a memory prompt from the i18n translations.
-
-    Args:
-        key: The prompt key under the "memory" section.
-
-    Returns:
-        The prompt string.
-    """
-    return get_i18n().memory(key)
-
-
-def extract_memories_from_content(content: str, llm: Any) -> list[str]:
-    """Use the LLM to extract discrete memory statements from raw content.
-
-    This is a pure helper: it does NOT store anything. Callers should call
-    memory.remember() on each returned string to persist them.
-
-    On LLM failure, returns the full content as a single memory so callers
-    still persist something rather than dropping the output.
-
-    Args:
-        content: Raw text (e.g. task description + result dump).
-        llm: The LLM instance to use.
-
-    Returns:
-        List of short, self-contained memory statements (or [content] on failure).
-    """
-    if not (content or "").strip():
-        return []
-    user = _get_prompt("extract_memories_user").format(content=content)
-    messages = [
-        {"role": "system", "content": _get_prompt("extract_memories_system")},
-        {"role": "user", "content": user},
-    ]
-    try:
-        if getattr(llm, "supports_function_calling", lambda: False)():
-            response = llm.call(messages, response_model=ExtractedMemories)
-            if isinstance(response, ExtractedMemories):
-                return response.memories
-            return ExtractedMemories.model_validate(response).memories
-        response = llm.call(messages)
-        if isinstance(response, ExtractedMemories):
-            return response.memories
-        if isinstance(response, str):
-            data = json.loads(response)
-            return ExtractedMemories.model_validate(data).memories
-        return ExtractedMemories.model_validate(response).memories
-    except Exception as e:
-        _logger.warning(
-            "Memory extraction failed, storing full content as single memory: %s",
-            e,
-            exc_info=False,
-        )
-        return [content]
-
-
-def analyze_query(
-    query: str,
-    available_scopes: list[str],
-    scope_info: ScopeInfo | None,
-    llm: Any,
-) -> QueryAnalysis:
-    """Use the LLM to analyze a recall query.
-
-    On LLM failure, returns safe defaults so recall degrades to plain vector search.
-
-    Args:
-        query: The user's recall query.
-        available_scopes: Scope paths that exist in the store.
-        scope_info: Optional info about the current scope.
-        llm: The LLM instance to use.
-
-    Returns:
-        QueryAnalysis with keywords, suggested_scopes, complexity, recall_queries, time_filter.
-    """
-    scope_desc = ""
-    if scope_info:
-        scope_desc = f"Current scope has {scope_info.record_count} records, categories: {scope_info.categories}"
-    user = _get_prompt("query_user").format(
-        query=query,
-        available_scopes=available_scopes or ["/"],
-        scope_desc=scope_desc,
-    )
-    messages = [
-        {"role": "system", "content": _get_prompt("query_system")},
-        {"role": "user", "content": user},
-    ]
-    try:
-        if getattr(llm, "supports_function_calling", lambda: False)():
-            response = llm.call(messages, response_model=QueryAnalysis)
-            if isinstance(response, QueryAnalysis):
-                return response
-            return QueryAnalysis.model_validate(response)
-        response = llm.call(messages)
-        if isinstance(response, QueryAnalysis):
-            return response
-        if isinstance(response, str):
-            data = json.loads(response)
-            return QueryAnalysis.model_validate(data)
-        return QueryAnalysis.model_validate(response)
-    except Exception as e:
-        _logger.warning(
-            "Query analysis failed, using defaults (complexity=simple): %s",
-            e,
-            exc_info=False,
-        )
-        scopes = (available_scopes or ["/"])[:5]
-        return QueryAnalysis(
-            keywords=[],
-            suggested_scopes=scopes,
-            complexity="simple",
-            recall_queries=[query],
-        )
-
-
-_SAVE_DEFAULTS = MemoryAnalysis(
-    suggested_scope="/",
-    categories=[],
-    importance=0.5,
-    extracted_metadata=ExtractedMetadata(),
-)
-
-
-def analyze_for_save(
-    content: str,
-    existing_scopes: list[str],
-    existing_categories: list[str],
-    llm: Any,
-) -> MemoryAnalysis:
-    """Infer scope, categories, importance, and metadata for a single memory.
-
-    Uses the small ``MemoryAnalysis`` schema (4 fields) for fast LLM response.
-    On failure, returns safe defaults so the memory still gets persisted.
-
-    Args:
-        content: The memory content to analyze.
-        existing_scopes: Current scope paths in the memory store.
-        existing_categories: Current categories in use.
-        llm: The LLM instance to use.
-
-    Returns:
-        MemoryAnalysis with suggested_scope, categories, importance, extracted_metadata.
-    """
-    user = _get_prompt("save_user").format(
-        content=content,
-        existing_scopes=existing_scopes or ["/"],
-        existing_categories=existing_categories or [],
-    )
-    messages = [
-        {"role": "system", "content": _get_prompt("save_system")},
-        {"role": "user", "content": user},
-    ]
-    try:
-        if getattr(llm, "supports_function_calling", lambda: False)():
-            response = llm.call(messages, response_model=MemoryAnalysis)
-            if isinstance(response, MemoryAnalysis):
-                return response
-            return MemoryAnalysis.model_validate(response)
-        response = llm.call(messages)
-        if isinstance(response, MemoryAnalysis):
-            return response
-        if isinstance(response, str):
-            data = json.loads(response)
-            return MemoryAnalysis.model_validate(data)
-        return MemoryAnalysis.model_validate(response)
-    except Exception as e:
-        _logger.warning(
-            "Memory save analysis failed, using defaults: %s", e, exc_info=False,
-        )
-        return _SAVE_DEFAULTS
-
-
-_CONSOLIDATION_DEFAULT = ConsolidationPlan(actions=[], insert_new=True)
-
-
-def analyze_for_consolidation(
-    new_content: str,
-    existing_records: list[MemoryRecord],
-    llm: Any,
-) -> ConsolidationPlan:
-    """Decide insert/update/delete for a single memory against similar existing records.
-
-    Uses the small ``ConsolidationPlan`` schema (3 fields) for fast LLM response.
-    On failure, returns a safe default (insert_new=True) so the memory still gets persisted.
-
-    Args:
-        new_content: The new content to store.
-        existing_records: Existing records that are semantically similar.
-        llm: The LLM instance to use.
-
-    Returns:
-        ConsolidationPlan with actions per record and whether to insert the new content.
-    """
-    if not existing_records:
-        return ConsolidationPlan(actions=[], insert_new=True)
-    records_lines: list[str] = []
-    for r in existing_records:
-        created = r.created_at.isoformat() if r.created_at else ""
-        records_lines.append(
-            f"- id={r.id} | scope={r.scope} | importance={r.importance:.2f} | created={created}\n"
-            f"  content: {r.content[:200]}{'...' if len(r.content) > 200 else ''}"
-        )
-    user = _get_prompt("consolidation_user").format(
-        new_content=new_content,
-        records_summary="\n\n".join(records_lines),
-    )
-    messages = [
-        {"role": "system", "content": _get_prompt("consolidation_system")},
-        {"role": "user", "content": user},
-    ]
-    try:
-        if getattr(llm, "supports_function_calling", lambda: False)():
-            response = llm.call(messages, response_model=ConsolidationPlan)
-            if isinstance(response, ConsolidationPlan):
-                return response
-            return ConsolidationPlan.model_validate(response)
-        response = llm.call(messages)
-        if isinstance(response, ConsolidationPlan):
-            return response
-        if isinstance(response, str):
-            data = json.loads(response)
-            return ConsolidationPlan.model_validate(data)
-        return ConsolidationPlan.model_validate(response)
-    except Exception as e:
-        _logger.warning(
-            "Consolidation analysis failed, defaulting to insert: %s", e, exc_info=False,
-        )
-        return _CONSOLIDATION_DEFAULT

lib/crewai/src/crewai/memory/contextual/contextual_memory.py

@@ -0,0 +1,254 @@
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+
+from crewai.memory import (
+    EntityMemory,
+    ExternalMemory,
+    LongTermMemory,
+    ShortTermMemory,
+)
+
+
+if TYPE_CHECKING:
+    from crewai.agent import Agent
+    from crewai.task import Task
+
+
+class ContextualMemory:
+    """Aggregates and retrieves context from multiple memory sources."""
+
+    def __init__(
+        self,
+        stm: ShortTermMemory,
+        ltm: LongTermMemory,
+        em: EntityMemory,
+        exm: ExternalMemory,
+        agent: Agent | None = None,
+        task: Task | None = None,
+    ) -> None:
+        self.stm = stm
+        self.ltm = ltm
+        self.em = em
+        self.exm = exm
+        self.agent = agent
+        self.task = task
+
+        if self.stm is not None:
+            self.stm.agent = self.agent
+            self.stm.task = self.task
+        if self.ltm is not None:
+            self.ltm.agent = self.agent
+            self.ltm.task = self.task
+        if self.em is not None:
+            self.em.agent = self.agent
+            self.em.task = self.task
+        if self.exm is not None:
+            self.exm.agent = self.agent
+            self.exm.task = self.task
+
+    def build_context_for_task(self, task: Task, context: str) -> str:
+        """Build contextual information for a task synchronously.
+
+        Args:
+            task: The task to build context for.
+            context: Additional context string.
+
+        Returns:
+            Formatted context string from all memory sources.
+        """
+        query = f"{task.description} {context}".strip()
+
+        if query == "":
+            return ""
+
+        context_parts = [
+            self._fetch_ltm_context(task.description),
+            self._fetch_stm_context(query),
+            self._fetch_entity_context(query),
+            self._fetch_external_context(query),
+        ]
+        return "\n".join(filter(None, context_parts))
+
+    async def abuild_context_for_task(self, task: Task, context: str) -> str:
+        """Build contextual information for a task asynchronously.
+
+        Args:
+            task: The task to build context for.
+            context: Additional context string.
+
+        Returns:
+            Formatted context string from all memory sources.
+        """
+        query = f"{task.description} {context}".strip()
+
+        if query == "":
+            return ""
+
+        # Fetch all contexts concurrently
+        results = await asyncio.gather(
+            self._afetch_ltm_context(task.description),
+            self._afetch_stm_context(query),
+            self._afetch_entity_context(query),
+            self._afetch_external_context(query),
+        )
+
+        return "\n".join(filter(None, results))
+
+    def _fetch_stm_context(self, query: str) -> str:
+        """
+        Fetches recent relevant insights from STM related to the task's description and expected_output,
+        formatted as bullet points.
+        """
+
+        if self.stm is None:
+            return ""
+
+        stm_results = self.stm.search(query)
+        formatted_results = "\n".join(
+            [f"- {result['content']}" for result in stm_results]
+        )
+        return f"Recent Insights:\n{formatted_results}" if stm_results else ""
+
+    def _fetch_ltm_context(self, task: str) -> str | None:
+        """
+        Fetches historical data or insights from LTM that are relevant to the task's description and expected_output,
+        formatted as bullet points.
+        """
+
+        if self.ltm is None:
+            return ""
+
+        ltm_results = self.ltm.search(task, latest_n=2)
+        if not ltm_results:
+            return None
+
+        formatted_results = [
+            suggestion
+            for result in ltm_results
+            for suggestion in result["metadata"]["suggestions"]
+        ]
+        formatted_results = list(dict.fromkeys(formatted_results))
+        formatted_results = "\n".join([f"- {result}" for result in formatted_results])  # type: ignore # Incompatible types in assignment (expression has type "str", variable has type "list[str]")
+
+        return f"Historical Data:\n{formatted_results}" if ltm_results else ""
+
+    def _fetch_entity_context(self, query: str) -> str:
+        """
+        Fetches relevant entity information from Entity Memory related to the task's description and expected_output,
+        formatted as bullet points.
+        """
+        if self.em is None:
+            return ""
+
+        em_results = self.em.search(query)
+        formatted_results = "\n".join(
+            [f"- {result['content']}" for result in em_results]
+        )
+        return f"Entities:\n{formatted_results}" if em_results else ""
+
+    def _fetch_external_context(self, query: str) -> str:
+        """
+        Fetches and formats relevant information from External Memory.
+        Args:
+            query (str): The search query to find relevant information.
+        Returns:
+            str: Formatted information as bullet points, or an empty string if none found.
+        """
+        if self.exm is None:
+            return ""
+
+        external_memories = self.exm.search(query)
+
+        if not external_memories:
+            return ""
+
+        formatted_memories = "\n".join(
+            f"- {result['content']}" for result in external_memories
+        )
+        return f"External memories:\n{formatted_memories}"
+
+    async def _afetch_stm_context(self, query: str) -> str:
+        """Fetch recent relevant insights from STM asynchronously.
+
+        Args:
+            query: The search query.
+
+        Returns:
+            Formatted insights as bullet points, or empty string if none found.
+        """
+        if self.stm is None:
+            return ""
+
+        stm_results = await self.stm.asearch(query)
+        formatted_results = "\n".join(
+            [f"- {result['content']}" for result in stm_results]
+        )
+        return f"Recent Insights:\n{formatted_results}" if stm_results else ""
+
+    async def _afetch_ltm_context(self, task: str) -> str | None:
+        """Fetch historical data from LTM asynchronously.
+
+        Args:
+            task: The task description to search for.
+
+        Returns:
+            Formatted historical data as bullet points, or None if none found.
+        """
+        if self.ltm is None:
+            return ""
+
+        ltm_results = await self.ltm.asearch(task, latest_n=2)
+        if not ltm_results:
+            return None
+
+        formatted_results = [
+            suggestion
+            for result in ltm_results
+            for suggestion in result["metadata"]["suggestions"]
+        ]
+        formatted_results = list(dict.fromkeys(formatted_results))
+        formatted_results = "\n".join([f"- {result}" for result in formatted_results])  # type: ignore # Incompatible types in assignment (expression has type "str", variable has type "list[str]")
+
+        return f"Historical Data:\n{formatted_results}" if ltm_results else ""
+
+    async def _afetch_entity_context(self, query: str) -> str:
+        """Fetch relevant entity information asynchronously.
+
+        Args:
+            query: The search query.
+
+        Returns:
+            Formatted entity information as bullet points, or empty string if none found.
+        """
+        if self.em is None:
+            return ""
+
+        em_results = await self.em.asearch(query)
+        formatted_results = "\n".join(
+            [f"- {result['content']}" for result in em_results]
+        )
+        return f"Entities:\n{formatted_results}" if em_results else ""
+
+    async def _afetch_external_context(self, query: str) -> str:
+        """Fetch relevant information from External Memory asynchronously.
+
+        Args:
+            query: The search query.
+
+        Returns:
+            Formatted information as bullet points, or empty string if none found.
+        """
+        if self.exm is None:
+            return ""
+
+        external_memories = await self.exm.asearch(query)
+
+        if not external_memories:
+            return ""
+
+        formatted_memories = "\n".join(
+            f"- {result['content']}" for result in external_memories
+        )
+        return f"External memories:\n{formatted_memories}"

lib/crewai/src/crewai/memory/encoding_flow.py

@@ -1,444 +0,0 @@
-"""Batch-native encoding flow: full save pipeline for one or more memories.
-
-Orchestrates the encoding side of memory in a single Flow with 5 steps:
-1. Batch embed (ONE embedder call for all items)
-2. Intra-batch dedup (cosine matrix, drop near-exact duplicates)
-3. Parallel find similar (concurrent storage searches)
-4. Parallel analyze (N concurrent LLM calls -- field resolution + consolidation)
-5. Execute plans (batch re-embed updates + bulk insert)
-"""
-
-from __future__ import annotations
-
-from concurrent.futures import Future, ThreadPoolExecutor
-from datetime import datetime
-import math
-from typing import Any
-from uuid import uuid4
-
-from pydantic import BaseModel, Field
-
-from crewai.flow.flow import Flow, listen, start
-from crewai.memory.analyze import (
-    ConsolidationPlan,
-    MemoryAnalysis,
-    analyze_for_consolidation,
-    analyze_for_save,
-)
-from crewai.memory.types import MemoryConfig, MemoryRecord, embed_texts
-
-
-# ---------------------------------------------------------------------------
-# State models
-# ---------------------------------------------------------------------------
-
-
-class ItemState(BaseModel):
-    """Per-item tracking within a batch."""
-
-    content: str = ""
-    # Caller-provided (None = infer via LLM)
-    scope: str | None = None
-    categories: list[str] | None = None
-    metadata: dict[str, Any] | None = None
-    importance: float | None = None
-    source: str | None = None
-    private: bool = False
-    # Resolved values
-    resolved_scope: str = "/"
-    resolved_categories: list[str] = Field(default_factory=list)
-    resolved_metadata: dict[str, Any] = Field(default_factory=dict)
-    resolved_importance: float = 0.5
-    resolved_source: str | None = None
-    resolved_private: bool = False
-    # Embedding
-    embedding: list[float] = Field(default_factory=list)
-    # Intra-batch dedup
-    dropped: bool = False
-    # Consolidation
-    similar_records: list[MemoryRecord] = Field(default_factory=list)
-    top_similarity: float = 0.0
-    plan: ConsolidationPlan | None = None
-    result_record: MemoryRecord | None = None
-
-
-class EncodingState(BaseModel):
-    """Batch-level state for the encoding flow."""
-
-    id: str = Field(default_factory=lambda: str(uuid4()))
-    items: list[ItemState] = Field(default_factory=list)
-    # Aggregate stats
-    records_inserted: int = 0
-    records_updated: int = 0
-    records_deleted: int = 0
-    items_dropped_dedup: int = 0
-
-
-# ---------------------------------------------------------------------------
-# Flow
-# ---------------------------------------------------------------------------
-
-
-class EncodingFlow(Flow[EncodingState]):
-    """Batch-native encoding pipeline for memory.remember() / remember_many().
-
-    Processes N items through 5 sequential steps, maximising parallelism:
-    - ONE embedder call for all items
-    - N concurrent storage searches
-    - N concurrent individual LLM calls (field resolution + consolidation)
-    - ONE batch re-embed for updates + ONE bulk storage write
-    """
-
-    _skip_auto_memory: bool = True
-
-    initial_state = EncodingState
-
-    def __init__(
-        self,
-        storage: Any,
-        llm: Any,
-        embedder: Any,
-        config: MemoryConfig | None = None,
-    ) -> None:
-        super().__init__(suppress_flow_events=True)
-        self._storage = storage
-        self._llm = llm
-        self._embedder = embedder
-        self._config = config or MemoryConfig()
-
-    # ------------------------------------------------------------------
-    # Step 1: Batch embed (ONE embedder call)
-    # ------------------------------------------------------------------
-
-    @start()
-    def batch_embed(self) -> None:
-        """Embed all items in a single embedder call."""
-        items = list(self.state.items)
-        texts = [item.content for item in items]
-        embeddings = embed_texts(self._embedder, texts)
-        for item, emb in zip(items, embeddings, strict=False):
-            item.embedding = emb
-
-    # ------------------------------------------------------------------
-    # Step 2: Intra-batch dedup (cosine similarity matrix)
-    # ------------------------------------------------------------------
-
-    @listen(batch_embed)
-    def intra_batch_dedup(self) -> None:
-        """Drop near-exact duplicates within the batch."""
-        items = list(self.state.items)
-        if len(items) <= 1:
-            return
-
-        threshold = self._config.batch_dedup_threshold
-        n = len(items)
-        for j in range(1, n):
-            if items[j].dropped or not items[j].embedding:
-                continue
-            for i in range(j):
-                if items[i].dropped or not items[i].embedding:
-                    continue
-                sim = self._cosine_similarity(items[i].embedding, items[j].embedding)
-                if sim >= threshold:
-                    items[j].dropped = True
-                    self.state.items_dropped_dedup += 1
-                    break
-
-    @staticmethod
-    def _cosine_similarity(a: list[float], b: list[float]) -> float:
-        """Compute cosine similarity between two vectors."""
-        if len(a) != len(b) or not a:
-            return 0.0
-        dot = sum(x * y for x, y in zip(a, b, strict=False))
-        norm_a = math.sqrt(sum(x * x for x in a))
-        norm_b = math.sqrt(sum(x * x for x in b))
-        if norm_a == 0.0 or norm_b == 0.0:
-            return 0.0
-        return dot / (norm_a * norm_b)
-
-    # ------------------------------------------------------------------
-    # Step 3: Parallel find similar (concurrent storage searches)
-    # ------------------------------------------------------------------
-
-    @listen(intra_batch_dedup)
-    def parallel_find_similar(self) -> None:
-        """Search storage for similar records, concurrently for all active items."""
-        items = list(self.state.items)
-        active = [(i, item) for i, item in enumerate(items) if not item.dropped and item.embedding]
-
-        if not active:
-            return
-
-        def _search_one(item: ItemState) -> list[tuple[MemoryRecord, float]]:
-            scope_prefix = item.scope if item.scope and item.scope.strip("/") else None
-            return self._storage.search(
-                item.embedding,
-                scope_prefix=scope_prefix,
-                categories=None,
-                limit=self._config.consolidation_limit,
-                min_score=0.0,
-            )
-
-        if len(active) == 1:
-            _, item = active[0]
-            raw = _search_one(item)
-            item.similar_records = [r for r, _ in raw]
-            item.top_similarity = float(raw[0][1]) if raw else 0.0
-        else:
-            with ThreadPoolExecutor(max_workers=min(len(active), 8)) as pool:
-                futures = [(i, item, pool.submit(_search_one, item)) for i, item in active]
-                for _, item, future in futures:
-                    raw = future.result()
-                    item.similar_records = [r for r, _ in raw]
-                    item.top_similarity = float(raw[0][1]) if raw else 0.0
-
-    # ------------------------------------------------------------------
-    # Step 4: Parallel analyze (N concurrent LLM calls)
-    # ------------------------------------------------------------------
-
-    @listen(parallel_find_similar)
-    def parallel_analyze(self) -> None:
-        """Field resolution + consolidation via parallel individual LLM calls.
-
-        Classifies each active item into one of four groups:
-        - Group A: fields provided + no similar records -> fast insert, 0 LLM calls.
-        - Group B: fields provided + similar records above threshold -> 1 consolidation call.
-        - Group C: fields missing + no similar records -> 1 field-resolution call.
-        - Group D: fields missing + similar records above threshold -> 2 concurrent calls.
-
-        All LLM calls across all items run in parallel via ThreadPoolExecutor.
-        """
-        items = list(self.state.items)
-        threshold = self._config.consolidation_threshold
-
-        # Pre-fetch scope/category info (shared across all field-resolution calls)
-        any_needs_fields = any(
-            not it.dropped
-            and (it.scope is None or it.categories is None or it.importance is None)
-            for it in items
-        )
-        existing_scopes: list[str] = []
-        existing_categories: list[str] = []
-        if any_needs_fields:
-            existing_scopes = self._storage.list_scopes("/") or ["/"]
-            existing_categories = list(
-                self._storage.list_categories(scope_prefix=None).keys()
-            )
-
-        # Classify items and submit LLM calls
-        save_futures: dict[int, Future[MemoryAnalysis]] = {}
-        consol_futures: dict[int, Future[ConsolidationPlan]] = {}
-
-        pool = ThreadPoolExecutor(max_workers=10)
-        try:
-            for i, item in enumerate(items):
-                if item.dropped:
-                    continue
-
-                fields_provided = (
-                    item.scope is not None
-                    and item.categories is not None
-                    and item.importance is not None
-                )
-                has_similar = item.top_similarity >= threshold
-
-                if fields_provided and not has_similar:
-                    # Group A: fast path
-                    self._apply_defaults(item)
-                    item.plan = ConsolidationPlan(actions=[], insert_new=True)
-                elif fields_provided and has_similar:
-                    # Group B: consolidation only
-                    self._apply_defaults(item)
-                    consol_futures[i] = pool.submit(
-                        analyze_for_consolidation,
-                        item.content, list(item.similar_records), self._llm,
-                    )
-                elif not fields_provided and not has_similar:
-                    # Group C: field resolution only
-                    save_futures[i] = pool.submit(
-                        analyze_for_save,
-                        item.content, existing_scopes, existing_categories, self._llm,
-                    )
-                else:
-                    # Group D: both in parallel
-                    save_futures[i] = pool.submit(
-                        analyze_for_save,
-                        item.content, existing_scopes, existing_categories, self._llm,
-                    )
-                    consol_futures[i] = pool.submit(
-                        analyze_for_consolidation,
-                        item.content, list(item.similar_records), self._llm,
-                    )
-
-            # Collect field-resolution results
-            for i, future in save_futures.items():
-                analysis = future.result()
-                item = items[i]
-                item.resolved_scope = item.scope or analysis.suggested_scope or "/"
-                item.resolved_categories = (
-                    item.categories
-                    if item.categories is not None
-                    else analysis.categories
-                )
-                item.resolved_importance = (
-                    item.importance
-                    if item.importance is not None
-                    else analysis.importance
-                )
-                item.resolved_metadata = dict(
-                    item.metadata or {},
-                    **(
-                        analysis.extracted_metadata.model_dump()
-                        if analysis.extracted_metadata
-                        else {}
-                    ),
-                )
-                item.resolved_source = item.source
-                item.resolved_private = item.private
-                # If no consolidation future, it's Group C -> insert
-                if i not in consol_futures:
-                    item.plan = ConsolidationPlan(actions=[], insert_new=True)
-
-            # Collect consolidation results
-            for i, future in consol_futures.items():
-                items[i].plan = future.result()
-        finally:
-            pool.shutdown(wait=False)
-
-    def _apply_defaults(self, item: ItemState) -> None:
-        """Apply caller values with config defaults (fast path)."""
-        item.resolved_scope = item.scope or "/"
-        item.resolved_categories = item.categories or []
-        item.resolved_metadata = item.metadata or {}
-        item.resolved_importance = (
-            item.importance
-            if item.importance is not None
-            else self._config.default_importance
-        )
-        item.resolved_source = item.source
-        item.resolved_private = item.private
-
-    # ------------------------------------------------------------------
-    # Step 5: Execute plans (batch re-embed + bulk insert)
-    # ------------------------------------------------------------------
-
-    @listen(parallel_analyze)
-    def execute_plans(self) -> None:
-        """Apply all consolidation plans with batch re-embedding and bulk insert.
-
-        Actions are deduplicated across items before applying: when multiple
-        items reference the same existing record (e.g. both want to delete it),
-        only the first action is applied. This prevents LanceDB commit
-        conflicts from two operations targeting the same record.
-        """
-        items = list(self.state.items)
-        now = datetime.utcnow()
-
-        # --- Deduplicate actions across all items ---
-        # Multiple items may reference the same existing record (because their
-        # similar_records overlap). Collect one action per record_id, first wins.
-        # Also build a map from record_id to the original MemoryRecord for updates.
-        dedup_deletes: set[str] = set()  # record_ids to delete
-        dedup_updates: dict[str, tuple[int, str]] = {}  # record_id -> (item_idx, new_content)
-        all_similar: dict[str, MemoryRecord] = {}  # record_id -> MemoryRecord
-
-        for i, item in enumerate(items):
-            if item.dropped or item.plan is None:
-                continue
-            for r in item.similar_records:
-                if r.id not in all_similar:
-                    all_similar[r.id] = r
-            for action in item.plan.actions:
-                rid = action.record_id
-                if action.action == "delete" and rid not in dedup_deletes and rid not in dedup_updates:
-                    dedup_deletes.add(rid)
-                elif action.action == "update" and action.new_content and rid not in dedup_deletes and rid not in dedup_updates:
-                    dedup_updates[rid] = (i, action.new_content)
-
-        # --- Batch re-embed all update contents in ONE call ---
-        update_list = list(dedup_updates.items())  # [(record_id, (item_idx, new_content)), ...]
-        update_embeddings: list[list[float]] = []
-        if update_list:
-            update_contents = [content for _, (_, content) in update_list]
-            update_embeddings = embed_texts(self._embedder, update_contents)
-
-        update_emb_map: dict[str, list[float]] = {}
-        for (rid, _), emb in zip(update_list, update_embeddings, strict=False):
-            update_emb_map[rid] = emb
-
-        # --- Apply all storage mutations under one lock ---
-        # Hold the write lock for the entire delete + update + insert sequence
-        # so no other pipeline can interleave and cause version conflicts.
-        # The lock is reentrant (RLock), so the individual storage methods
-        # can re-acquire it without deadlocking.
-        # Collect records to insert (outside lock -- pure data assembly)
-        to_insert: list[tuple[int, MemoryRecord]] = []
-        for i, item in enumerate(items):
-            if item.dropped or item.plan is None:
-                continue
-            if item.plan.insert_new:
-                to_insert.append((i, MemoryRecord(
-                    content=item.content,
-                    scope=item.resolved_scope,
-                    categories=item.resolved_categories,
-                    metadata=item.resolved_metadata,
-                    importance=item.resolved_importance,
-                    embedding=item.embedding if item.embedding else None,
-                    source=item.resolved_source,
-                    private=item.resolved_private,
-                )))
-
-        # All storage mutations under one lock so no other pipeline can
-        # interleave and cause version conflicts. The lock is reentrant
-        # (RLock) so the individual storage methods re-acquire it safely.
-        updated_records: dict[str, MemoryRecord] = {}
-        with self._storage.write_lock:
-            if dedup_deletes:
-                self._storage.delete(record_ids=list(dedup_deletes))
-                self.state.records_deleted += len(dedup_deletes)
-
-            for rid, (_item_idx, new_content) in dedup_updates.items():
-                existing = all_similar.get(rid)
-                if existing is not None:
-                    new_emb = update_emb_map.get(rid, [])
-                    updated = MemoryRecord(
-                        id=existing.id,
-                        content=new_content,
-                        scope=existing.scope,
-                        categories=existing.categories,
-                        metadata=existing.metadata,
-                        importance=existing.importance,
-                        created_at=existing.created_at,
-                        last_accessed=now,
-                        embedding=new_emb if new_emb else existing.embedding,
-                    )
-                    self._storage.update(updated)
-                    self.state.records_updated += 1
-                    updated_records[rid] = updated
-
-            if to_insert:
-                records = [r for _, r in to_insert]
-                self._storage.save(records)
-                self.state.records_inserted += len(records)
-                for idx, record in to_insert:
-                    items[idx].result_record = record
-
-        # Set result_record for non-insert items (after lock, using updated_records)
-        for _i, item in enumerate(items):
-            if item.dropped or item.plan is None or item.plan.insert_new:
-                continue
-            if item.result_record is not None:
-                continue
-            first_updated = next(
-                (
-                    updated_records[a.record_id]
-                    for a in item.plan.actions
-                    if a.action == "update" and a.record_id in updated_records
-                ),
-                None,
-            )
-            item.result_record = (
-                first_updated
-                if first_updated is not None
-                else (item.similar_records[0] if item.similar_records else None)
-            )

lib/crewai/src/crewai/memory/entity/entity_memory.py

@@ -0,0 +1,404 @@
+import time
+from typing import Any
+
+from pydantic import PrivateAttr
+
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.memory_events import (
+    MemoryQueryCompletedEvent,
+    MemoryQueryFailedEvent,
+    MemoryQueryStartedEvent,
+    MemorySaveCompletedEvent,
+    MemorySaveFailedEvent,
+    MemorySaveStartedEvent,
+)
+from crewai.memory.entity.entity_memory_item import EntityMemoryItem
+from crewai.memory.memory import Memory
+from crewai.memory.storage.rag_storage import RAGStorage
+
+
+class EntityMemory(Memory):
+    """
+    EntityMemory class for managing structured information about entities
+    and their relationships using SQLite storage.
+    Inherits from the Memory class.
+    """
+
+    _memory_provider: str | None = PrivateAttr()
+
+    def __init__(
+        self,
+        crew: Any = None,
+        embedder_config: Any = None,
+        storage: Any = None,
+        path: str | None = None,
+    ) -> None:
+        memory_provider = None
+        if embedder_config and isinstance(embedder_config, dict):
+            memory_provider = embedder_config.get("provider")
+
+        if memory_provider == "mem0":
+            try:
+                from crewai.memory.storage.mem0_storage import Mem0Storage
+            except ImportError as e:
+                raise ImportError(
+                    "Mem0 is not installed. Please install it with `pip install mem0ai`."
+                ) from e
+            config = (
+                embedder_config.get("config")
+                if embedder_config and isinstance(embedder_config, dict)
+                else None
+            )
+            storage = Mem0Storage(type="short_term", crew=crew, config=config)  # type: ignore[no-untyped-call]
+        else:
+            storage = (
+                storage
+                if storage
+                else RAGStorage(
+                    type="entities",
+                    allow_reset=True,
+                    embedder_config=embedder_config,
+                    crew=crew,
+                    path=path,
+                )
+            )
+
+        super().__init__(storage=storage)
+        self._memory_provider = memory_provider
+
+    def save(
+        self,
+        value: EntityMemoryItem | list[EntityMemoryItem],
+        metadata: dict[str, Any] | None = None,
+    ) -> None:
+        """Saves one or more entity items into the SQLite storage.
+
+        Args:
+            value: Single EntityMemoryItem or list of EntityMemoryItems to save.
+            metadata: Optional metadata dict (included for supertype compatibility but not used).
+
+        Notes:
+            The metadata parameter is included to satisfy the supertype signature but is not
+            used - entity metadata is extracted from the EntityMemoryItem objects themselves.
+        """
+
+        if not value:
+            return
+
+        items = value if isinstance(value, list) else [value]
+        is_batch = len(items) > 1
+
+        metadata = {"entity_count": len(items)} if is_batch else items[0].metadata
+        crewai_event_bus.emit(
+            self,
+            event=MemorySaveStartedEvent(
+                metadata=metadata,
+                source_type="entity_memory",
+                from_agent=self.agent,
+                from_task=self.task,
+            ),
+        )
+
+        start_time = time.time()
+        saved_count = 0
+        errors = []
+
+        def save_single_item(item: EntityMemoryItem) -> tuple[bool, str | None]:
+            """Save a single item and return success status."""
+            try:
+                if self._memory_provider == "mem0":
+                    data = f"""
+                    Remember details about the following entity:
+                    Name: {item.name}
+                    Type: {item.type}
+                    Entity Description: {item.description}
+                    """
+                else:
+                    data = f"{item.name}({item.type}): {item.description}"
+
+                super(EntityMemory, self).save(data, item.metadata)
+                return True, None
+            except Exception as e:
+                return False, f"{item.name}: {e!s}"
+
+        try:
+            for item in items:
+                success, error = save_single_item(item)
+                if success:
+                    saved_count += 1
+                else:
+                    errors.append(error)
+
+            if is_batch:
+                emit_value = f"Saved {saved_count} entities"
+                metadata = {"entity_count": saved_count, "errors": errors}
+            else:
+                emit_value = f"{items[0].name}({items[0].type}): {items[0].description}"
+                metadata = items[0].metadata
+
+            crewai_event_bus.emit(
+                self,
+                event=MemorySaveCompletedEvent(
+                    value=emit_value,
+                    metadata=metadata,
+                    save_time_ms=(time.time() - start_time) * 1000,
+                    source_type="entity_memory",
+                    from_agent=self.agent,
+                    from_task=self.task,
+                ),
+            )
+
+            if errors:
+                raise Exception(
+                    f"Partial save: {len(errors)} failed out of {len(items)}"
+                )
+
+        except Exception as e:
+            fail_metadata = (
+                {"entity_count": len(items), "saved": saved_count}
+                if is_batch
+                else items[0].metadata
+            )
+            crewai_event_bus.emit(
+                self,
+                event=MemorySaveFailedEvent(
+                    metadata=fail_metadata,
+                    error=str(e),
+                    source_type="entity_memory",
+                    from_agent=self.agent,
+                    from_task=self.task,
+                ),
+            )
+            raise
+
+    def search(
+        self,
+        query: str,
+        limit: int = 5,
+        score_threshold: float = 0.6,
+    ) -> list[Any]:
+        """Search entity memory for relevant entries.
+
+        Args:
+            query: The search query.
+            limit: Maximum number of results to return.
+            score_threshold: Minimum similarity score for results.
+
+        Returns:
+            List of matching memory entries.
+        """
+        crewai_event_bus.emit(
+            self,
+            event=MemoryQueryStartedEvent(
+                query=query,
+                limit=limit,
+                score_threshold=score_threshold,
+                source_type="entity_memory",
+                from_agent=self.agent,
+                from_task=self.task,
+            ),
+        )
+
+        start_time = time.time()
+        try:
+            results = super().search(
+                query=query, limit=limit, score_threshold=score_threshold
+            )
+
+            crewai_event_bus.emit(
+                self,
+                event=MemoryQueryCompletedEvent(
+                    query=query,
+                    results=results,
+                    limit=limit,
+                    score_threshold=score_threshold,
+                    query_time_ms=(time.time() - start_time) * 1000,
+                    source_type="entity_memory",
+                    from_agent=self.agent,
+                    from_task=self.task,
+                ),
+            )
+
+            return results
+        except Exception as e:
+            crewai_event_bus.emit(
+                self,
+                event=MemoryQueryFailedEvent(
+                    query=query,
+                    limit=limit,
+                    score_threshold=score_threshold,
+                    error=str(e),
+                    source_type="entity_memory",
+                ),
+            )
+            raise
+
+    async def asave(
+        self,
+        value: EntityMemoryItem | list[EntityMemoryItem],
+        metadata: dict[str, Any] | None = None,
+    ) -> None:
+        """Save entity items asynchronously.
+
+        Args:
+            value: Single EntityMemoryItem or list of EntityMemoryItems to save.
+            metadata: Optional metadata dict (not used, for signature compatibility).
+        """
+        if not value:
+            return
+
+        items = value if isinstance(value, list) else [value]
+        is_batch = len(items) > 1
+
+        metadata = {"entity_count": len(items)} if is_batch else items[0].metadata
+        crewai_event_bus.emit(
+            self,
+            event=MemorySaveStartedEvent(
+                metadata=metadata,
+                source_type="entity_memory",
+                from_agent=self.agent,
+                from_task=self.task,
+            ),
+        )
+
+        start_time = time.time()
+        saved_count = 0
+        errors: list[str | None] = []
+
+        async def save_single_item(item: EntityMemoryItem) -> tuple[bool, str | None]:
+            """Save a single item asynchronously."""
+            try:
+                if self._memory_provider == "mem0":
+                    data = f"""
+                    Remember details about the following entity:
+                    Name: {item.name}
+                    Type: {item.type}
+                    Entity Description: {item.description}
+                    """
+                else:
+                    data = f"{item.name}({item.type}): {item.description}"
+
+                await super(EntityMemory, self).asave(data, item.metadata)
+                return True, None
+            except Exception as e:
+                return False, f"{item.name}: {e!s}"
+
+        try:
+            for item in items:
+                success, error = await save_single_item(item)
+                if success:
+                    saved_count += 1
+                else:
+                    errors.append(error)
+
+            if is_batch:
+                emit_value = f"Saved {saved_count} entities"
+                metadata = {"entity_count": saved_count, "errors": errors}
+            else:
+                emit_value = f"{items[0].name}({items[0].type}): {items[0].description}"
+                metadata = items[0].metadata
+
+            crewai_event_bus.emit(
+                self,
+                event=MemorySaveCompletedEvent(
+                    value=emit_value,
+                    metadata=metadata,
+                    save_time_ms=(time.time() - start_time) * 1000,
+                    source_type="entity_memory",
+                    from_agent=self.agent,
+                    from_task=self.task,
+                ),
+            )
+
+            if errors:
+                raise Exception(
+                    f"Partial save: {len(errors)} failed out of {len(items)}"
+                )
+
+        except Exception as e:
+            fail_metadata = (
+                {"entity_count": len(items), "saved": saved_count}
+                if is_batch
+                else items[0].metadata
+            )
+            crewai_event_bus.emit(
+                self,
+                event=MemorySaveFailedEvent(
+                    metadata=fail_metadata,
+                    error=str(e),
+                    source_type="entity_memory",
+                    from_agent=self.agent,
+                    from_task=self.task,
+                ),
+            )
+            raise
+
+    async def asearch(
+        self,
+        query: str,
+        limit: int = 5,
+        score_threshold: float = 0.6,
+    ) -> list[Any]:
+        """Search entity memory asynchronously.
+
+        Args:
+            query: The search query.
+            limit: Maximum number of results to return.
+            score_threshold: Minimum similarity score for results.
+
+        Returns:
+            List of matching memory entries.
+        """
+        crewai_event_bus.emit(
+            self,
+            event=MemoryQueryStartedEvent(
+                query=query,
+                limit=limit,
+                score_threshold=score_threshold,
+                source_type="entity_memory",
+                from_agent=self.agent,
+                from_task=self.task,
+            ),
+        )
+
+        start_time = time.time()
+        try:
+            results = await super().asearch(
+                query=query, limit=limit, score_threshold=score_threshold
+            )
+
+            crewai_event_bus.emit(
+                self,
+                event=MemoryQueryCompletedEvent(
+                    query=query,
+                    results=results,
+                    limit=limit,
+                    score_threshold=score_threshold,
+                    query_time_ms=(time.time() - start_time) * 1000,
+                    source_type="entity_memory",
+                    from_agent=self.agent,
+                    from_task=self.task,
+                ),
+            )
+
+            return results
+        except Exception as e:
+            crewai_event_bus.emit(
+                self,
+                event=MemoryQueryFailedEvent(
+                    query=query,
+                    limit=limit,
+                    score_threshold=score_threshold,
+                    error=str(e),
+                    source_type="entity_memory",
+                ),
+            )
+            raise
+
+    def reset(self) -> None:
+        try:
+            self.storage.reset()
+        except Exception as e:
+            raise Exception(
+                f"An error occurred while resetting the entity memory: {e}"
+            ) from e

lib/crewai/src/crewai/memory/entity/entity_memory_item.py

@@ -0,0 +1,12 @@
+class EntityMemoryItem:
+    def __init__(
+        self,
+        name: str,
+        type: str,
+        description: str,
+        relationships: str,
+    ):
+        self.name = name
+        self.type = type
+        self.description = description
+        self.metadata = {"relationships": relationships}

lib/crewai/src/crewai/memory/external/external_memory.py

@@ -0,0 +1,301 @@
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, Any
+
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.memory_events import (
+    MemoryQueryCompletedEvent,
+    MemoryQueryFailedEvent,
+    MemoryQueryStartedEvent,
+    MemorySaveCompletedEvent,
+    MemorySaveFailedEvent,
+    MemorySaveStartedEvent,
+)
+from crewai.memory.external.external_memory_item import ExternalMemoryItem
+from crewai.memory.memory import Memory
+from crewai.memory.storage.interface import Storage
+from crewai.rag.embeddings.types import ProviderSpec
+
+
+if TYPE_CHECKING:
+    from crewai.memory.storage.mem0_storage import Mem0Storage
+
+
+class ExternalMemory(Memory):
+    def __init__(self, storage: Storage | None = None, **data: Any):
+        super().__init__(storage=storage, **data)
+
+    @staticmethod
+    def _configure_mem0(crew: Any, config: dict[str, Any]) -> Mem0Storage:
+        from crewai.memory.storage.mem0_storage import Mem0Storage
+
+        return Mem0Storage(type="external", crew=crew, config=config)  # type: ignore[no-untyped-call]
+
+    @staticmethod
+    def external_supported_storages() -> dict[str, Any]:
+        return {
+            "mem0": ExternalMemory._configure_mem0,
+        }
+
+    @staticmethod
+    def create_storage(
+        crew: Any, embedder_config: dict[str, Any] | ProviderSpec | None
+    ) -> Storage:
+        if not embedder_config:
+            raise ValueError("embedder_config is required")
+
+        if "provider" not in embedder_config:
+            raise ValueError("embedder_config must include a 'provider' key")
+
+        provider = embedder_config["provider"]
+        supported_storages = ExternalMemory.external_supported_storages()
+        if provider not in supported_storages:
+            raise ValueError(f"Provider {provider} not supported")
+
+        storage: Storage = supported_storages[provider](
+            crew, embedder_config.get("config", {})
+        )
+        return storage
+
+    def save(
+        self,
+        value: Any,
+        metadata: dict[str, Any] | None = None,
+    ) -> None:
+        """Saves a value into the external storage."""
+        crewai_event_bus.emit(
+            self,
+            event=MemorySaveStartedEvent(
+                value=value,
+                metadata=metadata,
+                source_type="external_memory",
+                from_agent=self.agent,
+                from_task=self.task,
+            ),
+        )
+
+        start_time = time.time()
+        try:
+            item = ExternalMemoryItem(
+                value=value,
+                metadata=metadata,
+                agent=self.agent.role if self.agent else None,
+            )
+            super().save(value=item.value, metadata=item.metadata)
+
+            crewai_event_bus.emit(
+                self,
+                event=MemorySaveCompletedEvent(
+                    value=value,
+                    metadata=metadata,
+                    save_time_ms=(time.time() - start_time) * 1000,
+                    source_type="external_memory",
+                    from_agent=self.agent,
+                    from_task=self.task,
+                ),
+            )
+        except Exception as e:
+            crewai_event_bus.emit(
+                self,
+                event=MemorySaveFailedEvent(
+                    value=value,
+                    metadata=metadata,
+                    error=str(e),
+                    source_type="external_memory",
+                    from_agent=self.agent,
+                    from_task=self.task,
+                ),
+            )
+            raise
+
+    def search(
+        self,
+        query: str,
+        limit: int = 5,
+        score_threshold: float = 0.6,
+    ) -> list[Any]:
+        """Search external memory for relevant entries.
+
+        Args:
+            query: The search query.
+            limit: Maximum number of results to return.
+            score_threshold: Minimum similarity score for results.
+
+        Returns:
+            List of matching memory entries.
+        """
+        crewai_event_bus.emit(
+            self,
+            event=MemoryQueryStartedEvent(
+                query=query,
+                limit=limit,
+                score_threshold=score_threshold,
+                source_type="external_memory",
+                from_agent=self.agent,
+                from_task=self.task,
+            ),
+        )
+
+        start_time = time.time()
+        try:
+            results = super().search(
+                query=query, limit=limit, score_threshold=score_threshold
+            )
+
+            crewai_event_bus.emit(
+                self,
+                event=MemoryQueryCompletedEvent(
+                    query=query,
+                    results=results,
+                    limit=limit,
+                    score_threshold=score_threshold,
+                    query_time_ms=(time.time() - start_time) * 1000,
+                    source_type="external_memory",
+                    from_agent=self.agent,
+                    from_task=self.task,
+                ),
+            )
+
+            return results
+        except Exception as e:
+            crewai_event_bus.emit(
+                self,
+                event=MemoryQueryFailedEvent(
+                    query=query,
+                    limit=limit,
+                    score_threshold=score_threshold,
+                    error=str(e),
+                    source_type="external_memory",
+                ),
+            )
+            raise
+
+    async def asave(
+        self,
+        value: Any,
+        metadata: dict[str, Any] | None = None,
+    ) -> None:
+        """Save a value to external memory asynchronously.
+
+        Args:
+            value: The value to save.
+            metadata: Optional metadata to associate with the value.
+        """
+        crewai_event_bus.emit(
+            self,
+            event=MemorySaveStartedEvent(
+                value=value,
+                metadata=metadata,
+                source_type="external_memory",
+                from_agent=self.agent,
+                from_task=self.task,
+            ),
+        )
+
+        start_time = time.time()
+        try:
+            item = ExternalMemoryItem(
+                value=value,
+                metadata=metadata,
+                agent=self.agent.role if self.agent else None,
+            )
+            await super().asave(value=item.value, metadata=item.metadata)
+
+            crewai_event_bus.emit(
+                self,
+                event=MemorySaveCompletedEvent(
+                    value=value,
+                    metadata=metadata,
+                    save_time_ms=(time.time() - start_time) * 1000,
+                    source_type="external_memory",
+                    from_agent=self.agent,
+                    from_task=self.task,
+                ),
+            )
+        except Exception as e:
+            crewai_event_bus.emit(
+                self,
+                event=MemorySaveFailedEvent(
+                    value=value,
+                    metadata=metadata,
+                    error=str(e),
+                    source_type="external_memory",
+                    from_agent=self.agent,
+                    from_task=self.task,
+                ),
+            )
+            raise
+
+    async def asearch(
+        self,
+        query: str,
+        limit: int = 5,
+        score_threshold: float = 0.6,
+    ) -> list[Any]:
+        """Search external memory asynchronously.
+
+        Args:
+            query: The search query.
+            limit: Maximum number of results to return.
+            score_threshold: Minimum similarity score for results.
+
+        Returns:
+            List of matching memory entries.
+        """
+        crewai_event_bus.emit(
+            self,
+            event=MemoryQueryStartedEvent(
+                query=query,
+                limit=limit,
+                score_threshold=score_threshold,
+                source_type="external_memory",
+                from_agent=self.agent,
+                from_task=self.task,
+            ),
+        )
+
+        start_time = time.time()
+        try:
+            results = await super().asearch(
+                query=query, limit=limit, score_threshold=score_threshold
+            )
+
+            crewai_event_bus.emit(
+                self,
+                event=MemoryQueryCompletedEvent(
+                    query=query,
+                    results=results,
+                    limit=limit,
+                    score_threshold=score_threshold,
+                    query_time_ms=(time.time() - start_time) * 1000,
+                    source_type="external_memory",
+                    from_agent=self.agent,
+                    from_task=self.task,
+                ),
+            )
+
+            return results
+        except Exception as e:
+            crewai_event_bus.emit(
+                self,
+                event=MemoryQueryFailedEvent(
+                    query=query,
+                    limit=limit,
+                    score_threshold=score_threshold,
+                    error=str(e),
+                    source_type="external_memory",
+                ),
+            )
+            raise
+
+    def reset(self) -> None:
+        self.storage.reset()
+
+    def set_crew(self, crew: Any) -> ExternalMemory:
+        super().set_crew(crew)
+
+        if not self.storage:
+            self.storage = self.create_storage(crew, self.embedder_config)  # type: ignore[arg-type]
+
+        return self

lib/crewai/src/crewai/memory/external/external_memory_item.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+
+class ExternalMemoryItem:
+    def __init__(
+        self,
+        value: Any,
+        metadata: dict[str, Any] | None = None,
+        agent: str | None = None,
+    ):
+        self.value = value
+        self.metadata = metadata
+        self.agent = agent