@synsci/cli-darwin-arm64 1.1.97 → 1.1.99

package/bin/skills/chembl-database/scripts/example_queries.py

@@ -1,278 +0,0 @@
-#!/usr/bin/env python3
-"""
-ChEMBL Database Query Examples
-
-This script demonstrates common query patterns for the ChEMBL database
-using the chembl_webresource_client Python library.
-
-Requirements:
-    pip install chembl_webresource_client
-    pip install pandas (optional, for data manipulation)
-"""
-
-from chembl_webresource_client.new_client import new_client
-
-
-def get_molecule_info(chembl_id):
-    """
-    Retrieve detailed information about a molecule by ChEMBL ID.
-
-    Args:
-        chembl_id: ChEMBL identifier (e.g., 'CHEMBL25')
-
-    Returns:
-        Dictionary containing molecule information
-    """
-    molecule = new_client.molecule
-    return molecule.get(chembl_id)
-
-
-def search_molecules_by_name(name_pattern):
-    """
-    Search for molecules by name pattern.
-
-    Args:
-        name_pattern: Name or pattern to search for
-
-    Returns:
-        List of matching molecules
-    """
-    molecule = new_client.molecule
-    results = molecule.filter(pref_name__icontains=name_pattern)
-    return list(results)
-
-
-def find_molecules_by_properties(max_mw=500, min_logp=None, max_logp=None):
-    """
-    Find molecules based on physicochemical properties.
-
-    Args:
-        max_mw: Maximum molecular weight
-        min_logp: Minimum LogP value
-        max_logp: Maximum LogP value
-
-    Returns:
-        List of matching molecules
-    """
-    molecule = new_client.molecule
-
-    filters = {
-        'molecule_properties__mw_freebase__lte': max_mw
-    }
-
-    if min_logp is not None:
-        filters['molecule_properties__alogp__gte'] = min_logp
-    if max_logp is not None:
-        filters['molecule_properties__alogp__lte'] = max_logp
-
-    results = molecule.filter(**filters)
-    return list(results)
-
-
-def get_target_info(target_chembl_id):
-    """
-    Retrieve information about a biological target.
-
-    Args:
-        target_chembl_id: ChEMBL target identifier (e.g., 'CHEMBL240')
-
-    Returns:
-        Dictionary containing target information
-    """
-    target = new_client.target
-    return target.get(target_chembl_id)
-
-
-def search_targets_by_name(target_name):
-    """
-    Search for targets by name or keyword.
-
-    Args:
-        target_name: Target name or keyword (e.g., 'kinase', 'EGFR')
-
-    Returns:
-        List of matching targets
-    """
-    target = new_client.target
-    results = target.filter(
-        target_type='SINGLE PROTEIN',
-        pref_name__icontains=target_name
-    )
-    return list(results)
-
-
-def get_bioactivity_data(target_chembl_id, activity_type='IC50', max_value=100):
-    """
-    Retrieve bioactivity data for a specific target.
-
-    Args:
-        target_chembl_id: ChEMBL target identifier
-        activity_type: Type of activity (IC50, Ki, EC50, etc.)
-        max_value: Maximum activity value in nM
-
-    Returns:
-        List of activity records
-    """
-    activity = new_client.activity
-    results = activity.filter(
-        target_chembl_id=target_chembl_id,
-        standard_type=activity_type,
-        standard_value__lte=max_value,
-        standard_units='nM'
-    )
-    return list(results)
-
-
-def find_similar_compounds(smiles, similarity_threshold=85):
-    """
-    Find compounds similar to a query structure.
-
-    Args:
-        smiles: SMILES string of query molecule
-        similarity_threshold: Minimum similarity percentage (0-100)
-
-    Returns:
-        List of similar compounds
-    """
-    similarity = new_client.similarity
-    results = similarity.filter(
-        smiles=smiles,
-        similarity=similarity_threshold
-    )
-    return list(results)
-
-
-def substructure_search(smiles):
-    """
-    Search for compounds containing a specific substructure.
-
-    Args:
-        smiles: SMILES string of substructure
-
-    Returns:
-        List of compounds containing the substructure
-    """
-    substructure = new_client.substructure
-    results = substructure.filter(smiles=smiles)
-    return list(results)
-
-
-def get_drug_info(molecule_chembl_id):
-    """
-    Retrieve drug information including indications and mechanisms.
-
-    Args:
-        molecule_chembl_id: ChEMBL molecule identifier
-
-    Returns:
-        Tuple of (drug_info, mechanisms, indications)
-    """
-    drug = new_client.drug
-    mechanism = new_client.mechanism
-    drug_indication = new_client.drug_indication
-
-    try:
-        drug_info = drug.get(molecule_chembl_id)
-    except:
-        drug_info = None
-
-    mechanisms = list(mechanism.filter(molecule_chembl_id=molecule_chembl_id))
-    indications = list(drug_indication.filter(molecule_chembl_id=molecule_chembl_id))
-
-    return drug_info, mechanisms, indications
-
-
-def find_kinase_inhibitors(max_ic50=100):
-    """
-    Find potent kinase inhibitors.
-
-    Args:
-        max_ic50: Maximum IC50 value in nM
-
-    Returns:
-        List of kinase inhibitor activities
-    """
-    target = new_client.target
-    activity = new_client.activity
-
-    # Find kinase targets
-    kinase_targets = target.filter(
-        target_type='SINGLE PROTEIN',
-        pref_name__icontains='kinase'
-    )
-
-    # Get target IDs
-    target_ids = [t['target_chembl_id'] for t in kinase_targets[:10]]  # Limit to first 10
-
-    # Find activities
-    results = activity.filter(
-        target_chembl_id__in=target_ids,
-        standard_type='IC50',
-        standard_value__lte=max_ic50,
-        standard_units='nM'
-    )
-
-    return list(results)
-
-
-def get_compound_bioactivities(molecule_chembl_id):
-    """
-    Get all bioactivity data for a specific compound.
-
-    Args:
-        molecule_chembl_id: ChEMBL molecule identifier
-
-    Returns:
-        List of all activity records for the compound
-    """
-    activity = new_client.activity
-    results = activity.filter(
-        molecule_chembl_id=molecule_chembl_id,
-        pchembl_value__isnull=False
-    )
-    return list(results)
-
-
-def export_to_dataframe(data):
-    """
-    Convert ChEMBL data to pandas DataFrame (requires pandas).
-
-    Args:
-        data: List of ChEMBL records
-
-    Returns:
-        pandas DataFrame
-    """
-    try:
-        import pandas as pd
-        return pd.DataFrame(data)
-    except ImportError:
-        print("pandas not installed. Install with: pip install pandas")
-        return None
-
-
-# Example usage
-if __name__ == "__main__":
-    print("ChEMBL Database Query Examples")
-    print("=" * 50)
-
-    # Example 1: Get information about aspirin
-    print("\n1. Getting information about aspirin (CHEMBL25)...")
-    aspirin = get_molecule_info('CHEMBL25')
-    print(f"Name: {aspirin.get('pref_name')}")
-    print(f"Formula: {aspirin.get('molecule_properties', {}).get('full_molformula')}")
-
-    # Example 2: Search for EGFR inhibitors
-    print("\n2. Searching for EGFR targets...")
-    egfr_targets = search_targets_by_name('EGFR')
-    if egfr_targets:
-        print(f"Found {len(egfr_targets)} EGFR-related targets")
-        print(f"First target: {egfr_targets[0]['pref_name']}")
-
-    # Example 3: Find potent activities for a target
-    print("\n3. Finding potent compounds for EGFR (CHEMBL203)...")
-    activities = get_bioactivity_data('CHEMBL203', 'IC50', max_value=10)
-    print(f"Found {len(activities)} compounds with IC50 <= 10 nM")
-
-    print("\n" + "=" * 50)
-    print("Examples completed successfully!")

package/bin/skills/chroma/SKILL.md

@@ -1,406 +0,0 @@
----
-name: chroma
-description: Open-source embedding database for AI applications. Store embeddings and metadata, perform vector and full-text search, filter by metadata. Simple 4-function API. Scales from notebooks to production clusters. Use for semantic search, RAG applications, or document retrieval. Best for local development and open-source projects.
-version: 1.0.0
-author: Synthetic Sciences
-license: MIT
-tags: [RAG, Chroma, Vector Database, Embeddings, Semantic Search, Open Source, Self-Hosted, Document Retrieval, Metadata Filtering]
-dependencies: [chromadb, sentence-transformers]
----
-
-# Chroma - Open-Source Embedding Database
-
-The AI-native database for building LLM applications with memory.
-
-## When to use Chroma
-
-**Use Chroma when:**
-- Building RAG (retrieval-augmented generation) applications
-- Need local/self-hosted vector database
-- Want open-source solution (Apache 2.0)
-- Prototyping in notebooks
-- Semantic search over documents
-- Storing embeddings with metadata
-
-**Metrics**:
-- **24,300+ GitHub stars**
-- **1,900+ forks**
-- **v1.3.3** (stable, weekly releases)
-- **Apache 2.0 license**
-
-**Use alternatives instead**:
-- **Pinecone**: Managed cloud, auto-scaling
-- **FAISS**: Pure similarity search, no metadata
-- **Weaviate**: Production ML-native database
-- **Qdrant**: High performance, Rust-based
-
-## Quick start
-
-### Installation
-
-```bash
-# Python
-pip install chromadb
-
-# JavaScript/TypeScript
-npm install chromadb @chroma-core/default-embed
-```
-
-### Basic usage (Python)
-
-```python
-import chromadb
-
-# Create client
-client = chromadb.Client()
-
-# Create collection
-collection = client.create_collection(name="my_collection")
-
-# Add documents
-collection.add(
-    documents=["This is document 1", "This is document 2"],
-    metadatas=[{"source": "doc1"}, {"source": "doc2"}],
-    ids=["id1", "id2"]
-)
-
-# Query
-results = collection.query(
-    query_texts=["document about topic"],
-    n_results=2
-)
-
-print(results)
-```
-
-## Core operations
-
-### 1. Create collection
-
-```python
-# Simple collection
-collection = client.create_collection("my_docs")
-
-# With custom embedding function
-from chromadb.utils import embedding_functions
-
-openai_ef = embedding_functions.OpenAIEmbeddingFunction(
-    api_key="your-key",
-    model_name="text-embedding-3-small"
-)
-
-collection = client.create_collection(
-    name="my_docs",
-    embedding_function=openai_ef
-)
-
-# Get existing collection
-collection = client.get_collection("my_docs")
-
-# Delete collection
-client.delete_collection("my_docs")
-```
-
-### 2. Add documents
-
-```python
-# Add with auto-generated IDs
-collection.add(
-    documents=["Doc 1", "Doc 2", "Doc 3"],
-    metadatas=[
-        {"source": "web", "category": "tutorial"},
-        {"source": "pdf", "page": 5},
-        {"source": "api", "timestamp": "2025-01-01"}
-    ],
-    ids=["id1", "id2", "id3"]
-)
-
-# Add with custom embeddings
-collection.add(
-    embeddings=[[0.1, 0.2, ...], [0.3, 0.4, ...]],
-    documents=["Doc 1", "Doc 2"],
-    ids=["id1", "id2"]
-)
-```
-
-### 3. Query (similarity search)
-
-```python
-# Basic query
-results = collection.query(
-    query_texts=["machine learning tutorial"],
-    n_results=5
-)
-
-# Query with filters
-results = collection.query(
-    query_texts=["Python programming"],
-    n_results=3,
-    where={"source": "web"}
-)
-
-# Query with metadata filters
-results = collection.query(
-    query_texts=["advanced topics"],
-    where={
-        "$and": [
-            {"category": "tutorial"},
-            {"difficulty": {"$gte": 3}}
-        ]
-    }
-)
-
-# Access results
-print(results["documents"])      # List of matching documents
-print(results["metadatas"])      # Metadata for each doc
-print(results["distances"])      # Similarity scores
-print(results["ids"])            # Document IDs
-```
-
-### 4. Get documents
-
-```python
-# Get by IDs
-docs = collection.get(
-    ids=["id1", "id2"]
-)
-
-# Get with filters
-docs = collection.get(
-    where={"category": "tutorial"},
-    limit=10
-)
-
-# Get all documents
-docs = collection.get()
-```
-
-### 5. Update documents
-
-```python
-# Update document content
-collection.update(
-    ids=["id1"],
-    documents=["Updated content"],
-    metadatas=[{"source": "updated"}]
-)
-```
-
-### 6. Delete documents
-
-```python
-# Delete by IDs
-collection.delete(ids=["id1", "id2"])
-
-# Delete with filter
-collection.delete(
-    where={"source": "outdated"}
-)
-```
-
-## Persistent storage
-
-```python
-# Persist to disk
-client = chromadb.PersistentClient(path="./chroma_db")
-
-collection = client.create_collection("my_docs")
-collection.add(documents=["Doc 1"], ids=["id1"])
-
-# Data persisted automatically
-# Reload later with same path
-client = chromadb.PersistentClient(path="./chroma_db")
-collection = client.get_collection("my_docs")
-```
-
-## Embedding functions
-
-### Default (Sentence Transformers)
-
-```python
-# Uses sentence-transformers by default
-collection = client.create_collection("my_docs")
-# Default model: all-MiniLM-L6-v2
-```
-
-### OpenAI
-
-```python
-from chromadb.utils import embedding_functions
-
-openai_ef = embedding_functions.OpenAIEmbeddingFunction(
-    api_key="your-key",
-    model_name="text-embedding-3-small"
-)
-
-collection = client.create_collection(
-    name="openai_docs",
-    embedding_function=openai_ef
-)
-```
-
-### HuggingFace
-
-```python
-huggingface_ef = embedding_functions.HuggingFaceEmbeddingFunction(
-    api_key="your-key",
-    model_name="sentence-transformers/all-mpnet-base-v2"
-)
-
-collection = client.create_collection(
-    name="hf_docs",
-    embedding_function=huggingface_ef
-)
-```
-
-### Custom embedding function
-
-```python
-from chromadb import Documents, EmbeddingFunction, Embeddings
-
-class MyEmbeddingFunction(EmbeddingFunction):
-    def __call__(self, input: Documents) -> Embeddings:
-        # Your embedding logic
-        return embeddings
-
-my_ef = MyEmbeddingFunction()
-collection = client.create_collection(
-    name="custom_docs",
-    embedding_function=my_ef
-)
-```
-
-## Metadata filtering
-
-```python
-# Exact match
-results = collection.query(
-    query_texts=["query"],
-    where={"category": "tutorial"}
-)
-
-# Comparison operators
-results = collection.query(
-    query_texts=["query"],
-    where={"page": {"$gt": 10}}  # $gt, $gte, $lt, $lte, $ne
-)
-
-# Logical operators
-results = collection.query(
-    query_texts=["query"],
-    where={
-        "$and": [
-            {"category": "tutorial"},
-            {"difficulty": {"$lte": 3}}
-        ]
-    }  # Also: $or
-)
-
-# Contains
-results = collection.query(
-    query_texts=["query"],
-    where={"tags": {"$in": ["python", "ml"]}}
-)
-```
-
-## LangChain integration
-
-```python
-from langchain_chroma import Chroma
-from langchain_openai import OpenAIEmbeddings
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-
-# Split documents
-text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
-docs = text_splitter.split_documents(documents)
-
-# Create Chroma vector store
-vectorstore = Chroma.from_documents(
-    documents=docs,
-    embedding=OpenAIEmbeddings(),
-    persist_directory="./chroma_db"
-)
-
-# Query
-results = vectorstore.similarity_search("machine learning", k=3)
-
-# As retriever
-retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
-```
-
-## LlamaIndex integration
-
-```python
-from llama_index.vector_stores.chroma import ChromaVectorStore
-from llama_index.core import VectorStoreIndex, StorageContext
-import chromadb
-
-# Initialize Chroma
-db = chromadb.PersistentClient(path="./chroma_db")
-collection = db.get_or_create_collection("my_collection")
-
-# Create vector store
-vector_store = ChromaVectorStore(chroma_collection=collection)
-storage_context = StorageContext.from_defaults(vector_store=vector_store)
-
-# Create index
-index = VectorStoreIndex.from_documents(
-    documents,
-    storage_context=storage_context
-)
-
-# Query
-query_engine = index.as_query_engine()
-response = query_engine.query("What is machine learning?")
-```
-
-## Server mode
-
-```python
-# Run Chroma server
-# Terminal: chroma run --path ./chroma_db --port 8000
-
-# Connect to server
-import chromadb
-from chromadb.config import Settings
-
-client = chromadb.HttpClient(
-    host="localhost",
-    port=8000,
-    settings=Settings(anonymized_telemetry=False)
-)
-
-# Use as normal
-collection = client.get_or_create_collection("my_docs")
-```
-
-## Best practices
-
-1. **Use persistent client** - Don't lose data on restart
-2. **Add metadata** - Enables filtering and tracking
-3. **Batch operations** - Add multiple docs at once
-4. **Choose right embedding model** - Balance speed/quality
-5. **Use filters** - Narrow search space
-6. **Unique IDs** - Avoid collisions
-7. **Regular backups** - Copy chroma_db directory
-8. **Monitor collection size** - Scale up if needed
-9. **Test embedding functions** - Ensure quality
-10. **Use server mode for production** - Better for multi-user
-
-## Performance
-
-| Operation | Latency | Notes |
-|-----------|---------|-------|
-| Add 100 docs | ~1-3s | With embedding |
-| Query (top 10) | ~50-200ms | Depends on collection size |
-| Metadata filter | ~10-50ms | Fast with proper indexing |
-
-## Resources
-
-- **GitHub**: https://github.com/chroma-core/chroma ⭐ 24,300+
-- **Docs**: https://docs.trychroma.com
-- **Discord**: https://discord.gg/MMeYNTmh3x
-- **Version**: 1.3.3+
-- **License**: Apache 2.0
-
-

package/bin/skills/chroma/references/integration.md

@@ -1,38 +0,0 @@
-# Chroma Integration Guide
-
-Integration with LangChain, LlamaIndex, and frameworks.
-
-## LangChain
-
-```python
-from langchain_chroma import Chroma
-from langchain_openai import OpenAIEmbeddings
-
-vectorstore = Chroma.from_documents(
-    documents=docs,
-    embedding=OpenAIEmbeddings(),
-    persist_directory="./chroma_db"
-)
-
-# Query
-results = vectorstore.similarity_search("query", k=3)
-
-# As retriever
-retriever = vectorstore.as_retriever()
-```
-
-## LlamaIndex
-
-```python
-from llama_index.vector_stores.chroma import ChromaVectorStore
-import chromadb
-
-db = chromadb.PersistentClient(path="./chroma_db")
-collection = db.get_or_create_collection("docs")
-
-vector_store = ChromaVectorStore(chroma_collection=collection)
-```
-
-## Resources
-
-- **Docs**: https://docs.trychroma.com