clap-agents 0.1.1__py3-none-any.whl → 0.2.1__py3-none-any.whl

clap/vector_stores/chroma_store.py

@@ -0,0 +1,142 @@
+import json
+import functools
+from typing import Any, Dict, List, Optional, cast
+import asyncio 
+import anyio
+
+_CHROMADB_LIB_AVAILABLE = False
+_ChromaDB_Client_Placeholder_Type = Any
+_ChromaDB_Collection_Placeholder_Type = Any
+_ChromaDB_Settings_Placeholder_Type = Any
+_ChromaDB_EmbeddingFunction_Placeholder_Type = Any
+_ChromaDB_DefaultEmbeddingFunction_Placeholder_Type = Any
+
+try:
+    import chromadb
+    from chromadb import Collection as ImportedChromaCollection
+    from chromadb.config import Settings as ImportedChromaSettings
+    from chromadb.utils.embedding_functions import (
+        EmbeddingFunction as ImportedChromaEF, 
+        DefaultEmbeddingFunction as ImportedChromaDefaultEF
+    )
+    from chromadb.api.types import Documents, Embeddings 
+    _CHROMADB_LIB_AVAILABLE = True
+    _ChromaDB_Client_Placeholder_Type = chromadb.Client
+    _ChromaDB_Collection_Placeholder_Type = ImportedChromaCollection
+    _ChromaDB_Settings_Placeholder_Type = ImportedChromaSettings
+    _ChromaDB_EmbeddingFunction_Placeholder_Type = ImportedChromaEF
+    _ChromaDB_DefaultEmbeddingFunction_Placeholder_Type = ImportedChromaDefaultEF
+except ImportError:
+    class Documents: pass 
+    class Embeddings: pass 
+    pass
+
+
+from .base import ( Document as ClapDocument, Embedding as ClapEmbedding, ID, Metadata, QueryResult, VectorStoreInterface,) # Aliased Document
+from clap.embedding.base_embedding import EmbeddingFunctionInterface as ClapEFInterface
+
+
+class _AsyncEFWrapperForChroma:
+    """Wraps an async CLAP EmbeddingFunctionInterface to be callable synchronously by Chroma."""
+    def __init__(self, async_ef_call: asyncio.coroutine, loop: asyncio.AbstractEventLoop):
+        self._async_ef_call = async_ef_call
+        self._loop = loop
+
+    def __call__(self, input: Documents) -> Embeddings: 
+        
+        if self._loop.is_running():
+            
+            future = asyncio.run_coroutine_threadsafe(self._async_ef_call(input), self._loop)
+            return future.result() 
+        else:
+            return self._loop.run_until_complete(self._async_ef_call(input))
+
+
+class ChromaStore(VectorStoreInterface):
+    _client: _ChromaDB_Client_Placeholder_Type
+    _collection: _ChromaDB_Collection_Placeholder_Type
+    _clap_ef_is_async: bool = False 
+
+    def __init__(
+        self,
+        collection_name: str,
+        embedding_function: Optional[ClapEFInterface] = None, # CLAP's interface
+        path: Optional[str] = None, host: Optional[str] = None, port: Optional[int] = None,
+        client_settings: Optional[_ChromaDB_Settings_Placeholder_Type] = None,
+    ):
+        if not _CHROMADB_LIB_AVAILABLE:
+            raise ImportError("The 'chromadb' library is required to use ChromaStore.")
+
+        self.collection_name = collection_name
+        
+        if path: self._client = chromadb.PersistentClient(path=path, settings=client_settings)
+        elif host and port: self._client = chromadb.HttpClient(host=host, port=port, settings=client_settings)
+        else: self._client = chromadb.EphemeralClient(settings=client_settings)
+       
+
+        chroma_ef_to_pass_to_chroma: Optional[_ChromaDB_EmbeddingFunction_Placeholder_Type]
+
+        if embedding_function is None:
+            chroma_ef_to_pass_to_chroma = _ChromaDB_DefaultEmbeddingFunction_Placeholder_Type()
+            self._clap_ef_is_async = False 
+            print(f"ChromaStore: Using ChromaDB's DefaultEmbeddingFunction for '{self.collection_name}'.")
+        
+        elif isinstance(embedding_function, _ChromaDB_DefaultEmbeddingFunction_Placeholder_Type): 
+            chroma_ef_to_pass_to_chroma = embedding_function
+            self._clap_ef_is_async = False 
+            print(f"ChromaStore: Using provided native Chroma EmbeddingFunction for '{self.collection_name}'.")
+        else:
+            
+            ef_call_method = getattr(embedding_function, "__call__", None)
+            if ef_call_method and asyncio.iscoroutinefunction(ef_call_method):
+                self._clap_ef_is_async = True
+                print(f"ChromaStore: Wrapping async CLAP EmbeddingFunction for Chroma compatibility for '{self.collection_name}'.")
+                
+                try:
+                    loop = asyncio.get_running_loop()
+                except RuntimeError: 
+                    
+                    print("ChromaStore WARNING: No running asyncio loop to wrap async EF for Chroma. This might fail.")
+                    
+                    loop = asyncio.new_event_loop() 
+                                                  
+
+                chroma_ef_to_pass_to_chroma = _AsyncEFWrapperForChroma(ef_call_method, loop) 
+            else: 
+                self._clap_ef_is_async = False
+                print(f"ChromaStore: Using synchronous CLAP EmbeddingFunction for '{self.collection_name}'.")
+                chroma_ef_to_pass_to_chroma = embedding_function # type: ignore
+
+        self._collection = self._client.get_or_create_collection(
+            name=self.collection_name,
+            embedding_function=chroma_ef_to_pass_to_chroma
+        )
+        # print(f"ChromaStore: Collection '{self.collection_name}' ready.")
+
+    
+    async def _run_sync(self, func, *args, **kwargs):
+        bound_func = functools.partial(func, *args, **kwargs)
+        return await anyio.to_thread.run_sync(bound_func)
+
+    async def add_documents(self, documents: List[ClapDocument], ids: List[ID], metadatas: Optional[List[Metadata]] = None, embeddings: Optional[List[ClapEmbedding]] = None) -> None:
+        
+        # print(f"ChromaStore: Adding {len(ids)} documents to '{self.collection_name}'...")
+        await self._run_sync(self._collection.add, ids=ids, embeddings=embeddings, metadatas=metadatas, documents=documents)
+        # print(f"ChromaStore: Add/Update completed for {len(ids)} documents.")
+
+    async def aquery(self, query_texts: Optional[List[ClapDocument]] = None, query_embeddings: Optional[List[ClapEmbedding]] = None, n_results: int = 5, where: Optional[Dict[str, Any]] = None, where_document: Optional[Dict[str, Any]] = None, include: List[str] = ["metadatas", "documents", "distances"]) -> QueryResult:
+        if not query_texts and not query_embeddings: raise ValueError("Requires query_texts or query_embeddings.")
+        if query_texts and query_embeddings: query_texts = None
+        
+       
+        # print(f"ChromaStore: Querying collection '{self.collection_name}'...")
+        results = await self._run_sync(self._collection.query, query_embeddings=query_embeddings, query_texts=query_texts, n_results=n_results, where=where, where_document=where_document, include=include)
+        
+        num_queries = len(query_texts or query_embeddings or [])
+       
+        return QueryResult(
+            ids=results.get("ids") or ([[]] * num_queries), embeddings=results.get("embeddings"),
+            documents=results.get("documents"), metadatas=results.get("metadatas"), distances=results.get("distances") )
+
+    async def adelete(self, ids: Optional[List[ID]] = None, where: Optional[Dict[str, Any]] = None, where_document: Optional[Dict[str, Any]] = None) -> None:
+        await self._run_sync(self._collection.delete, ids=ids, where=where, where_document=where_document)

clap/vector_stores/qdrant_store.py

@@ -0,0 +1,155 @@
+import asyncio
+import json
+import functools
+import os
+from typing import Any, Dict, List, Optional, cast, Type
+
+import anyio
+
+_QDRANT_LIB_AVAILABLE = False
+_AsyncQdrantClient_Placeholder_Type = Any
+_QdrantClient_Placeholder_Type = Any 
+_qdrant_models_Placeholder_Type = Any
+_QdrantUnexpectedResponse_Placeholder_Type = type(Exception)
+
+try:
+    from qdrant_client import AsyncQdrantClient as ImportedAsyncQC, QdrantClient as ImportedSyncQC, models as ImportedModels
+    from qdrant_client.http.exceptions import UnexpectedResponse as ImportedQdrantUnexpectedResponse
+    _QDRANT_LIB_AVAILABLE = True
+    _AsyncQdrantClient_Placeholder_Type = ImportedAsyncQC
+    _QdrantClient_Placeholder_Type = ImportedSyncQC 
+    _qdrant_models_Placeholder_Type = ImportedModels
+    _QdrantUnexpectedResponse_Placeholder_Type = ImportedQdrantUnexpectedResponse
+except ImportError:
+    pass
+
+
+from .base import ( Document, Embedding, ID, Metadata, QueryResult, VectorStoreInterface,)
+from clap.embedding.base_embedding import EmbeddingFunctionInterface
+
+
+class QdrantStore(VectorStoreInterface):
+    _async_client: _AsyncQdrantClient_Placeholder_Type
+    models: Any # For qdrant_client.models
+
+    def __init__(self):
+        if not hasattr(self, "_initialized_via_factory"):
+             raise RuntimeError("Use QdrantStore.create(...) async factory method.")
+
+    @classmethod
+    async def create(
+        cls: Type['QdrantStore'],
+        collection_name: str, embedding_function: EmbeddingFunctionInterface,
+        path: Optional[str] = None, distance_metric: Any = None, 
+        recreate_collection_if_exists: bool = False, **qdrant_client_kwargs: Any
+    ) -> 'QdrantStore':
+        if not _QDRANT_LIB_AVAILABLE:
+            raise ImportError("The 'qdrant-client' library is required. Install with 'pip install \"clap-agents[qdrant]\"'")
+        if not embedding_function: raise ValueError("embedding_function is required.")
+
+        instance = cls.__new__(cls)
+        instance._initialized_via_factory = True
+        instance.collection_name = collection_name
+        instance.models = _qdrant_models_Placeholder_Type 
+        instance._embedding_function = embedding_function
+        instance.distance_metric = distance_metric if distance_metric else instance.models.Distance.COSINE
+        instance.vector_size = instance._embedding_function.get_embedding_dimension()
+
+        client_location_for_log = path if path else ":memory:"
+        # print(f"QdrantStore (Async): Initializing client for '{instance.collection_name}' at '{client_location_for_log}'.")
+        if path: instance._async_client = _AsyncQdrantClient_Placeholder_Type(path=path, **qdrant_client_kwargs)
+        else: instance._async_client = _AsyncQdrantClient_Placeholder_Type(location=":memory:", **qdrant_client_kwargs)
+        
+        await instance._setup_collection_async(recreate_collection_if_exists)
+        return instance
+
+    async def _setup_collection_async(self, recreate_if_exists: bool):
+        try:
+            if recreate_if_exists:
+                await self._async_client.delete_collection(collection_name=self.collection_name)
+                await self._async_client.create_collection(
+                     collection_name=self.collection_name,
+                     vectors_config=self.models.VectorParams(size=self.vector_size, distance=self.distance_metric))
+                return
+            try:
+                info = await self._async_client.get_collection(collection_name=self.collection_name)
+                if info.config.params.size != self.vector_size or info.config.params.distance.lower() != self.distance_metric.lower(): # type: ignore
+                    raise ValueError("Existing Qdrant collection has incompatible config.")
+            except (_QdrantUnexpectedResponse_Placeholder_Type, ValueError) as e: # type: ignore
+                 if isinstance(e, _QdrantUnexpectedResponse_Placeholder_Type) and e.status_code == 404 or "not found" in str(e).lower(): # type: ignore
+                      await self._async_client.create_collection(
+                          collection_name=self.collection_name,
+                          vectors_config=self.models.VectorParams(size=self.vector_size, distance=self.distance_metric))
+                 else: raise
+        except Exception as e: print(f"QdrantStore: Error during collection setup: {e}"); raise
+
+
+    async def _embed_texts_via_interface(self, texts: List[Document]) -> List[Embedding]:
+        if not self._embedding_function: raise RuntimeError("EF missing.")
+        ef_call = self._embedding_function.__call__
+        if asyncio.iscoroutinefunction(ef_call): return await ef_call(texts) 
+        return await anyio.to_thread.run_sync(functools.partial(ef_call, texts)) 
+
+    async def add_documents(self, documents: List[Document], ids: List[ID], metadatas: Optional[List[Metadata]] = None, embeddings: Optional[List[Embedding]] = None) -> None:
+        if not documents and not embeddings: raise ValueError("Requires docs or embeddings.")
+        num_items = len(documents) if documents else (len(embeddings) if embeddings else 0)
+        if num_items == 0: return
+        if len(ids) != num_items: raise ValueError("'ids' length mismatch.")
+        if metadatas and len(metadatas) != num_items: raise ValueError("'metadatas' length mismatch.")
+        if not embeddings and documents: embeddings = await self._embed_texts_via_interface(documents)
+        if not embeddings: return
+        points: List[Any] = [] # Use Any for models.PointStruct if models is Any
+        for i, item_id in enumerate(ids):
+            payload = metadatas[i].copy() if metadatas and i < len(metadatas) else {}
+            if documents and i < len(documents): payload["_clap_document_content_"] = documents[i]
+            points.append(self.models.PointStruct(id=str(item_id), vector=embeddings[i], payload=payload))
+        if points: await self._async_client.upsert(collection_name=self.collection_name, points=points, wait=True)
+
+    async def aquery(self, query_texts: Optional[List[Document]] = None, query_embeddings: Optional[List[Embedding]] = None, n_results: int = 5, where: Optional[Dict[str, Any]] = None, include: List[str] = ["metadatas", "documents", "distances"], **kwargs) -> QueryResult:
+        if not query_texts and not query_embeddings: raise ValueError("Requires query_texts or query_embeddings.")
+        if query_texts and query_embeddings: query_texts = None
+        q_filter = self._translate_clap_filter(where) 
+        if query_texts: q_vectors = await self._embed_texts_via_interface(query_texts)
+        elif query_embeddings: q_vectors = query_embeddings
+        else: return QueryResult(ids=[[]], embeddings=None, documents=None, metadatas=None, distances=None)
+        raw_results: List[List[Any]] = [] 
+        for qv in q_vectors:
+            hits = await self._async_client.search(collection_name=self.collection_name, query_vector=qv, query_filter=q_filter, limit=n_results, with_payload=True, with_vectors="embeddings" in include, **kwargs)
+            raw_results.append(hits)
+        return self._format_qdrant_results(raw_results, include) # Keep using self.models
+
+    def _translate_clap_filter(self, clap_where_filter: Optional[Dict[str, Any]]) -> Optional[Any]: # Return Any
+        if not clap_where_filter or not _QDRANT_LIB_AVAILABLE: return None
+        must = []
+        for k, v in clap_where_filter.items():
+            if isinstance(v, dict) and "$eq" in v: must.append(self.models.FieldCondition(key=k, match=self.models.MatchValue(value=v["$eq"])))
+            elif isinstance(v, (str,int,float,bool)): must.append(self.models.FieldCondition(key=k, match=self.models.MatchValue(value=v)))
+        return self.models.Filter(must=must) if must else None
+
+    def _format_qdrant_results(self, raw_results: List[List[Any]], include: List[str]) -> QueryResult: 
+        ids, embs, docs, metas, dists_final = [], [], [], [], []
+        for hits_list in raw_results:
+            current_ids, current_embs, current_docs, current_metas, current_dists = [],[],[],[],[]
+            for hit in hits_list: 
+                current_ids.append(str(hit.id))
+                payload = hit.payload if hit.payload else {}
+                if "distances" in include and hit.score is not None: current_dists.append(hit.score)
+                if "embeddings" in include and hit.vector : current_embs.append(cast(List[float], hit.vector))
+                if "documents" in include : current_docs.append(payload.get("_clap_document_content_", ""))
+                if "metadatas" in include : current_metas.append({k:v for k,v in payload.items() if k != "_clap_document_content_"})
+            ids.append(current_ids); embs.append(current_embs); docs.append(current_docs); metas.append(current_metas); dists_final.append(current_dists)
+        return QueryResult(ids=ids, embeddings=embs if "embeddings" in include else None, documents=docs if "documents" in include else None, metadatas=metas if "metadatas" in include else None, distances=dists_final if "distances" in include else None)
+
+
+    async def adelete(self, ids: Optional[List[ID]] = None, where: Optional[Dict[str, Any]] = None, **kwargs ) -> None:
+        if not ids and not where: return
+        q_filter = self._translate_clap_filter(where)
+        selector: Any = None
+        if ids and q_filter: selector = self.models.FilterSelector(filter=self.models.Filter(must=[q_filter, self.models.HasIdCondition(has_id=[str(i) for i in ids])]))
+        elif ids: selector = self.models.PointIdsList(points=[str(i) for i in ids])
+        elif q_filter: selector = self.models.FilterSelector(filter=q_filter)
+        if selector: await self._async_client.delete(collection_name=self.collection_name, points_selector=selector, wait=True)
+
+    async def close(self):
+        if hasattr(self, '_async_client') and self._async_client:
+            await self._async_client.close(timeout=5)

{clap_agents-0.1.1.dist-info → clap_agents-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clap-agents
-Version: 0.1.1
+Version: 0.2.1
 Summary: A Python framework for building cognitive agentic patterns including ReAct agents, Multi-Agent Teams, native tool calling, and MCP client integration.
 Project-URL: Homepage, https://github.com/MaitreyaM/CLAP-AGENTS.git
 Project-URL: Repository, https://github.com/MaitreyaM/CLAP-AGENTS.git
@@ -233,44 +233,93 @@ Requires-Dist: openai>=1.0.0
 Requires-Dist: pydantic<3.0.0,>=2.7.2
 Requires-Dist: requests
 Provides-Extra: all
-Requires-Dist: clap[standard-tools,viz]; extra == 'all'
+Requires-Dist: chromadb>=0.5.0; extra == 'all'
+Requires-Dist: crawl4ai; extra == 'all'
+Requires-Dist: fastembed>=0.2.0; extra == 'all'
+Requires-Dist: graphviz; extra == 'all'
+Requires-Dist: ollama>=0.2.0; extra == 'all'
+Requires-Dist: pandas; extra == 'all'
+Requires-Dist: pypdf; extra == 'all'
+Requires-Dist: qdrant-client[fastembed]>=1.7.0; extra == 'all'
+Requires-Dist: sentence-transformers; extra == 'all'
+Provides-Extra: chromadb
+Requires-Dist: chromadb>=0.5.0; extra == 'chromadb'
+Provides-Extra: fastembed
+Requires-Dist: fastembed>=0.2.0; extra == 'fastembed'
+Provides-Extra: ollama
+Requires-Dist: ollama>=0.2.0; extra == 'ollama'
+Provides-Extra: pandas
+Requires-Dist: pandas; extra == 'pandas'
+Provides-Extra: pdf
+Requires-Dist: pypdf; extra == 'pdf'
+Provides-Extra: qdrant
+Requires-Dist: qdrant-client[fastembed]>=1.7.0; extra == 'qdrant'
+Provides-Extra: rag
+Requires-Dist: chromadb>=0.5.0; extra == 'rag'
+Requires-Dist: fastembed>=0.2.0; extra == 'rag'
+Requires-Dist: ollama>=0.2.0; extra == 'rag'
+Requires-Dist: pypdf; extra == 'rag'
+Requires-Dist: qdrant-client[fastembed]>=1.7.0; extra == 'rag'
+Requires-Dist: sentence-transformers; extra == 'rag'
+Provides-Extra: sentence-transformers
+Requires-Dist: sentence-transformers; extra == 'sentence-transformers'
 Provides-Extra: standard-tools
 Requires-Dist: crawl4ai; extra == 'standard-tools'
 Provides-Extra: viz
 Requires-Dist: graphviz; extra == 'viz'
 Description-Content-Type: text/markdown
 
-# CLAP - Cognitive Layer Agents Package
+<p align="center">
+  <img src="GITCLAP.png" alt="CLAP Logo" width="700" height="200"/>
+</p>
 
-[![PyPI version](https://img.shields.io/pypi/v/CLAP.svg)](https://pypi.org/project/CLAP/)
+# CLAP - Cognitive Layer Agent Package
+
+[![PyPI version](https://img.shields.io/pypi/v/clap-agents.svg)](https://pypi.org/project/clap-agents/) 
 [![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
-[![Python Version](https://img.shields.io/pypi/pyversions/CLAP.svg)](https://pypi.org/project/CLAP/)
-<!-- Add other badges as desired, e.g., build status, coverage -->
+[![Python Version](https://img.shields.io/pypi/pyversions/clap-agents.svg)](https://pypi.org/project/clap-agents/) 
 
-**CLAP (Cognitive Layer Agent Package)** is a Python framework providing building blocks for creating sophisticated AI agents based on modern agentic patterns. It enables developers to easily construct agents capable of reasoning, planning, and interacting with external tools and systems.
+**CLAP (Cognitive Layer Agent Package)** is a Python framework providing building blocks for creating sophisticated AI agents based on modern agentic patterns. It enables developers to easily construct agents capable of reasoning, planning, and interacting with external tools, systems, and knowledge bases.
 
 Built with an asynchronous core (`asyncio`), CLAP offers flexibility and performance for complex agentic workflows.
 
+<p align="center">
+  <img src="PIP CLAP.png" alt="CLAP Pip Install" width="700" height="200"/> <!-- Updated alt text -->
+</p>
+
 ## Key Features
 
 *   **Modular Agent Patterns:**
-    *   **ReAct Agent:** Implements the Reason-Act loop with robust thought-prompting and native tool calling.
+    *   **ReAct Agent:** Implements the Reason-Act loop with robust thought-prompting and native tool calling. Ideal for complex reasoning and RAG.
+    *   **Tool Agent:** A straightforward agent for single-step tool usage, including simple RAG.
     *   **Multi-Agent Teams:** Define teams of specialized agents with dependencies, enabling collaborative task execution (sequential or parallel).
-    *   **Simple Tool Agent:** A straightforward agent for single-step tool usage.
 *   **Advanced Tool Integration:**
     *   **Native LLM Tool Calling:** Leverages modern LLM APIs for reliable tool execution.
     *   **Local Tools:** Easily define and use local Python functions (both synchronous and asynchronous) as tools using the `@tool` decorator.
     *   **Remote Tools (MCP):** Integrates with [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) servers via the included `MCPClientManager`, allowing agents to discover and use tools exposed by external systems (currently supports SSE transport).
-    *   **Robust Validation:** Uses `jsonschema` for strict validation of tool arguments provided by the LLM.
+    *   **Robust Validation & Coercion:** Uses `jsonschema` for strict validation of tool arguments and attempts type coercion for common LLM outputs (e.g., string numbers to integers).
+*   **Retrieval Augmented Generation (RAG) Capabilities:**
+    *   **`VectorStoreInterface`:** An abstraction for interacting with various vector databases.
+    *   **Supported Vector Stores:**
+        *   **ChromaDB:** (`ChromaStore`) For local or self-hosted vector storage.
+        *   **Qdrant:** (`QdrantStore`) For local (in-memory or file-based) vector storage.
+    *   **`EmbeddingFunctionInterface`:** A protocol for consistent interaction with different embedding models.
+    *   **Supported Embedding Function Wrappers:**
+        *   `SentenceTransformerEmbeddings`: Uses models from the `sentence-transformers` library.
+        *   `OllamaEmbeddings`: Generates embeddings using models running locally via Ollama.
+        *   `FastEmbedEmbeddings`: Utilizes the `fastembed` library for CPU-optimized embeddings. (Note: Performance for very large batch ingestions via the async wrapper might vary based on CPU and may be slower than SentenceTransformers for initial bulk loads.)
+    *   **RAG-Aware Agents:** Both `Agent` (via `ReactAgent`) and `ToolAgent` can be equipped with a `vector_store` to perform `vector_query` tool calls, enabling them to retrieve context before responding.
+    *   **Utilities:** Includes basic PDF and CSV text loaders and chunking strategies in `clap.utils.rag_utils`.
 *   **Pluggable LLM Backends:**
     *   Uses a **Strategy Pattern** (`LLMServiceInterface`) to abstract LLM interactions.
     *   Includes ready-to-use service implementations for:
         *   **Groq:** (`GroqService`)
         *   **Google Generative AI (Gemini):** (`GoogleOpenAICompatService` via OpenAI compatibility layer)
+        *   **Ollama (Local LLMs):** (`OllamaOpenAICompatService` also known as `OllamaService` via OpenAI compatibility layer, allowing use of locally run models like Llama 3, Mistral, etc.)
     *   Easily extensible to support other LLM providers.
 *   **Asynchronous Core:** Built entirely on `asyncio` for efficient I/O operations and potential concurrency.
-*   **Structured Context Passing:** Enables clear and organized information flow between agents in a team using Python dictionaries.
-*   **Built-in Tools:** Includes helpers for web search, web scraping, and email interaction (optional dependencies may apply).
+*   **Structured Context Passing:** Enables clear and organized information flow between agents in a team.
+*   **Built-in Tools:** Includes helpers for web search (`duckduckgo_search`). More available via optional dependencies.
 
 ## Installation
 
@@ -278,13 +327,40 @@ Ensure you have Python 3.10 or later installed.
 
 ```bash
 pip install clap-agents
+```
+
+Ensure you have Python 3.10 or later installed.
+
+```bash
+pip install clap-agents
+
 
+To use specific features, you might need to install optional dependencies:
+# For Qdrant support (includes fastembed)
+pip install "clap-agents[qdrant]"
+
+# For ChromaDB support
+pip install "clap-agents[chromadb]"
+
+# For Ollama (LLM and/or Embeddings)
+pip install "clap-agents[ollama]"
+
+# For other tools like web crawling or visualization
+pip install "clap-agents[standard_tools,viz]"
+
+# To install all major optional dependencies
+pip install "clap-agents[all]"
+```
+
+
+Check the pyproject.toml for the full list of [project.optional-dependencies]. You will also need to have external services like Ollama or Qdrant (if used locally) running.
 Depending on the tools or LLM backends you intend to use, you might need additional dependencies listed in the pyproject.toml (e.g., groq, openai, mcp, jsonschema, requests, duckduckgo-search, graphviz). Check the [project.dependencies] and [project.optional-dependencies] sections.
 
 
-Quick Start: Simple Tool calling Agent with a Local Tool
+## Quick Start: Simple Tool calling Agent with a Local Tool
 This example demonstrates creating a Tool calling agent using the Groq backend and a local tool
 
+```
 from dotenv import load_dotenv
 from clap import ToolAgent
 from clap import duckduckgo_search
@@ -292,25 +368,24 @@ from clap import duckduckgo_search
 load_dotenv()
 
 async def main():
-    agent = ToolAgent(tools=duckduckgo_search, model="llama-3.3-70b-versatile")
+    agent = ToolAgent(tools=duckduckgo_search, model="meta-llama/llama-4-scout-17b-16e-instruct")
     user_query = "Search the web for recent news about AI advancements."
     response = await agent.run(user_msg=user_query)
     print(f"Response:\n{response}")
 
 asyncio.run(main())
+```
 
 
-
-Quick Start: Simple ReAct Agent with a Local Tool
+## Quick Start: Simple ReAct Agent with a Local Tool
 This example demonstrates creating a ReAct agent using the Groq backend and a local tool.
 
-
+```
 import asyncio
 import os
 from dotenv import load_dotenv
 from clap import ReactAgent, tool, GroqService
 
-# --- Setup ---
 load_dotenv() 
 @tool
 def get_word_length(word: str) -> int:
@@ -333,14 +408,117 @@ async def main():
     print(response)
     
 asyncio.run(main())
+```
+
+## Quick Start: Simple Tool-Calling Agent with Ollama
+This example demonstrates a ToolAgent using a local Ollama model and a local tool.
+Ensure Ollama is running and you have pulled the model (e.g., ollama pull llama3).
+
+```
+import asyncio
+from dotenv import load_dotenv
+from clap import ToolAgent, tool, OllamaService # Assuming OllamaService is your OllamaOpenAICompatService
+
+load_dotenv()
+
+@tool
+def get_capital(country: str) -> str:
+    """Returns the capital of a country."""
+    if country.lower() == "france": return "Paris"
+    return f"I don't know the capital of {country}."
+
+async def main():
+    # Initialize the Ollama service
+    ollama_llm_service = OllamaService(default_model="llama3") # Specify your Ollama model
+
+    agent = ToolAgent(
+        llm_service=ollama_llm_service,
+        model="llama3", # Model name for this agent
+        tools=[get_capital]
+    )
+    user_query = "What is the capital of France?"
+    response = await agent.run(user_msg=user_query)
+    print(f"Query: {user_query}\nResponse:\n{response}")
 
+    await ollama_llm_service.close() # Important for OllamaService
 
-Exploring Further
-Multi-Agent Teams: See examples/team_agent.py for setting up sequential or parallel agent workflows.
-MCP Integration: Check examples/minimal_react_mcp_test.py and examples/test_tool_agent_mcp.py (ensure the corresponding MCP server like examples/minimal_mcp_server.py is running).
-Google GenAI: Modify the Quick Start to use GoogleOpenAICompatService instead of GroqService (ensure GOOGLE_API_KEY is set and openai library is installed).
-Built-in Tools: Explore the tools provided in clap.tools (like duckduckgo_search, scrape_url, etc.).
+if __name__ == "__main__":
+    asyncio.run(main())
 
+```
+
+## Quick Start: RAG Agent with Qdrant and Ollama Embeddings
+This example shows an Agent performing RAG using Ollama for embeddings and Qdrant as the vector store.
+Ensure Ollama is running (with nomic-embed-text and llama3 pulled) and Qdrant is running (e.g., via Docker).
+```
+import asyncio
+import os
+import shutil
+from dotenv import load_dotenv
+from clap import Agent, QdrantStore, OllamaEmbeddings, OllamaService
+from clap.utils.rag_utils import chunk_text_by_fixed_size
+from qdrant_client import models as qdrant_models # If needed for distance
+
+load_dotenv()
+
+OLLAMA_HOST = "http://localhost:11434"
+EMBED_MODEL = "nomic-embed-text"
+LLM_MODEL = "llama3"
+DB_PATH = "./temp_rag_db_ollama_qdrant"
+COLLECTION = "my_rag_docs"
+
+async def main():
+    if os.path.exists(DB_PATH): shutil.rmtree(DB_PATH)
+
+    ollama_ef = OllamaEmbeddings(model_name=EMBED_MODEL, ollama_host=OLLAMA_HOST)
+    vector_store = await QdrantStore.create(
+        collection_name=COLLECTION,
+        embedding_function=ollama_ef,
+        path=DB_PATH, # For local file-based Qdrant
+        recreate_collection_if_exists=True
+    )
+
+    sample_texts = ["The sky is blue due to Rayleigh scattering.", "Large language models are powerful."]
+    chunks = [chunk for text in sample_texts for chunk in chunk_text_by_fixed_size(text, 100, 10)]
+    ids = [str(i) for i in range(len(chunks))] # Qdrant needs UUIDs; QdrantStore handles this
+    
+    if chunks:
+        await vector_store.add_documents(documents=chunks, ids=ids)
+    print(f"Ingested {len(chunks)} chunks.")
+
+    ollama_llm_service = OllamaService(default_model=LLM_MODEL, base_url=f"{OLLAMA_HOST}/v1")
+    rag_agent = Agent(
+        name="RAGMaster",
+        backstory="I answer questions using provided documents.",
+        task_description="Why is the sky blue according to the documents?", # This becomes the User Query
+        llm_service=ollama_llm_service,
+        model=LLM_MODEL,
+        vector_store=vector_store
+    )
+
+    response = await rag_agent.run()
+    print(f"Query: {rag_agent.task_description}\nResponse:\n{response.get('output')}")
+
+    await vector_store.close()
+    await ollama_llm_service.close()
+    if os.path.exists(DB_PATH): shutil.rmtree(DB_PATH)
+
+asyncio.run(main())
+```
+
+## Exploring Further
+
+
+# Multi-Agent Teams: See examples/test_clap_comprehensive_suite.py and other team examples for setting up sequential or parallel agent workflows.
+
+# MCP Integration: Check examples/test_clap_comprehensive_suite.py (ensure corresponding MCP servers from examples/simple_mcp.py etc. are running).
+
+# Other LLM Services (Groq, Google Gemini , Ollama): Modify the Quick Starts to use GroqService or GoogleOpenAICompatService (ensure API keys are set).
+
+# Different Vector Stores & Embedding Functions: Experiment with ChromaStore, QdrantStore, SentenceTransformerEmbeddings, FastEmbedEmbeddings, and OllamaEmbeddings as shown in the comprehensive test suite.
 
 License
 This project is licensed under the terms of the Apache License 2.0. See the LICENSE file for details.
+
+
+

clap_agents-0.2.1.dist-info/RECORD

@@ -0,0 +1,38 @@
+clap/__init__.py,sha256=rxxESl-xpSZpM4ZIh-GvHYF74CkQdbe-dSLvhMC_2dQ,1069
+clap/embedding/__init__.py,sha256=PqnqcSiA_JwEvn69g2DCQHdsffL2l4GNEKo0fAtCqbs,520
+clap/embedding/base_embedding.py,sha256=0SYicQ-A-rSDqHoFK0IOrRQe0cisOl8OBnis6V43Chs,696
+clap/embedding/fastembed_embedding.py,sha256=Xo2H7r45wNqN89WzI8InXtjahOXAcKDyHS0fYt_jtsc,2959
+clap/embedding/ollama_embedding.py,sha256=s7IYFs4BuM114Md1cqxim5WzCwCjbEJ48wAZZOgR7KQ,3702
+clap/embedding/sentence_transformer_embedding.py,sha256=0RAqGxDpjZVwerOLmVirqqnCwC07kHdfAPiy2fgOSCk,1798
+clap/llm_services/__init__.py,sha256=js__xIlkbXBLd2q1trYKjATYWa4xLNgPwwJz2Flwi0s,532
+clap/llm_services/base.py,sha256=BjSBVOtPMvPZJjI3HwSSI3OvVFyxd5HeOKLI9bN6P7M,2204
+clap/llm_services/google_openai_compat_service.py,sha256=X5ehwQEv4DobXCBjhtuo2v365DUl-thDa9Gdc16L67k,4522
+clap/llm_services/groq_service.py,sha256=HQoY3IpNHiOe0h6Gy0EMa1YsCUex0CvZ_MxApNMo8Ig,3206
+clap/llm_services/ollama_service.py,sha256=LsoJhCw8TZVbfuJeHATo2uPpkXsOWOuuE78HAxTQ9RY,5326
+clap/mcp_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+clap/mcp_client/client.py,sha256=wtbdAblkB8TNltvbC0pbthIFlpLoz_LsWj7sFnfaduw,8623
+clap/multiagent_pattern/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+clap/multiagent_pattern/agent.py,sha256=6Og1ZujhAIzQ_JLzuhc4oh9TwJ_mTXl2q2ca302PE8g,8345
+clap/multiagent_pattern/team.py,sha256=t8Xru3fVPblw75pyuPT1wmI3jlsrZHD_GKAW5APbpFg,7966
+clap/react_pattern/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+clap/react_pattern/react_agent.py,sha256=Ron5zz-yn5EHmnXiL5G1sDYF0-3DCiTVujZ2RJI27JQ,23478
+clap/tool_pattern/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+clap/tool_pattern/tool.py,sha256=7fHkLTPafsAWr_ECXZKpQz0zzqEAxSrQ56ns5oWcBSU,5964
+clap/tool_pattern/tool_agent.py,sha256=VTQv9DNU16zgINZKVcX5oDw1lPfw5Y_8bUnW6wad2vE,14439
+clap/tools/__init__.py,sha256=veMtEmjaY6aj_aUXNnPT_ijI2XM1DJU-y8dLqwx_t2s,293
+clap/tools/email_tools.py,sha256=18aAlbjcSaOzpf9R3H-EGeRsqL5gdzmcJJcW619xOHU,9729
+clap/tools/web_crawler.py,sha256=WdFbAKhUsUVveJimmLbzQ6k1BhOdMsg87FjL628HEKM,3542
+clap/tools/web_search.py,sha256=YT0I1kPrdxMUst-dpsGqqF6aqxMgj3ACwiW_jN9Pu9s,985
+clap/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+clap/utils/completions.py,sha256=xgHhXSJfPEOjQmeB2j6TpXEswMaDC87uCpIWXztSFBw,5613
+clap/utils/extraction.py,sha256=x0wK66E37aB7UIq6ms4Juf8Ga2Zdm12kYXCzL3AiwTI,1295
+clap/utils/logging.py,sha256=FfrOHXnVJYCgc3mepIMKcIcGSdSWkMpV7ccKPGFxFiM,727
+clap/utils/rag_utils.py,sha256=Zy-C9l39tHrxYSluaDWcEl1g__uozu4jx5hEGC7h370,6455
+clap/vector_stores/__init__.py,sha256=H3w5jLdQFbXArVgiidy4RlAalM8a6LAiMlAX0Z-2v7U,404
+clap/vector_stores/base.py,sha256=nvk8J1oNG3OKFhJfxBGFyVeh9YxoDs9RkB_iOzPBm1w,2853
+clap/vector_stores/chroma_store.py,sha256=knaZ91dC1M6T3yISLcn7PCQ5gZlh4xfeNLTVYD0k92E,7193
+clap/vector_stores/qdrant_store.py,sha256=-SwMTb0yaGngpQ9AddDzDIt3x8GZevlFT-0FMkWD28I,9923
+clap_agents-0.2.1.dist-info/METADATA,sha256=YE4izY_nqWF9OwbnOfS-bp-nk2a4y9jP1kbiiUk2QZk,27199
+clap_agents-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+clap_agents-0.2.1.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+clap_agents-0.2.1.dist-info/RECORD,,