Add agent rules page and files (#1575)

Co-authored-by: ekwuno <Obinnacodes@gmail.com>

Author: martinschaer

public/integrations/agent-rules/surrealdb-python-embedded.mdc

@@ -0,0 +1,73 @@
+---
+description: This rule provides information using SurrealDB embedded in python
+alwaysApply: false
+---
+
+The data can be stored:
+
+- in-memory with `Surreal("mem://")` and `AsyncSurreal("mem://")`
+- persistence with `Surreal(f"file://{db_path}")` and `AsyncSurreal(f"file://{db_path}")`
+
+## Example:
+
+```python
+"""File-based persistent embedded SurrealDB example."""
+
+import asyncio
+import tempfile
+from pathlib import Path
+
+from surrealdb import AsyncSurreal
+
+
+async def main() -> None:
+    """Run persistent file-based database operations."""
+    # Create a temporary directory for the database
+    with tempfile.TemporaryDirectory() as tmpdir:
+        db_path = Path(tmpdir) / "mydb"
+        db_url = f"file://{db_path}"
+
+        print(f"Using database at: {db_path}")
+
+        # First connection: create data
+        print("\n=== First connection: Creating data ===")
+        async with AsyncSurreal(db_url) as db:
+            await db.use("test", "test")
+
+            # Create some records
+            await db.create(
+                "company", {"name": "Acme Corp", "founded": 2020, "employees": 100}
+            )
+
+            await db.create(
+                "company", {"name": "TechStart Inc", "founded": 2021, "employees": 50}
+            )
+
+            companies = await db.select("company")
+            print(f"Created companies: {companies}")
+
+        # Second connection: verify persistence
+        print("\n=== Second connection: Verifying persistence ===")
+        async with AsyncSurreal(db_url) as db:
+            await db.use("test", "test")
+
+            # Query the persisted data
+            companies = await db.select("company")
+            print(f"Loaded companies from disk: {companies}")
+
+            # Update a company
+            updated = await db.query("""
+                UPDATE company SET employees = employees + 10 WHERE name = "Acme Corp"
+            """)
+            print(f"Updated company: {updated}")
+
+            # Verify the update
+            all_companies = await db.select("company")
+            print(f"All companies after update: {all_companies}")
+
+        print("\n=== Database file will be cleaned up automatically ===")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

public/integrations/agent-rules/surrealdb-python.mdc

@@ -0,0 +1,85 @@
+---
+description: This rule provides information using SurrealDB in python
+alwaysApply: false
+---
+
+## Running SurrealDB
+
+This will persist the data in a `database` folder:
+
+```bash
+surreal start -u root -p root rocksdb:database
+```
+
+This will store the data in-memory:
+
+```bash
+surreal start -u root -p root
+```
+
+## Example
+
+```python
+# Import the Surreal class
+from surrealdb import Surreal
+
+# Using a context manger to automatically connect and disconnect
+with Surreal("ws://localhost:8000/rpc") as db:
+    db.signin({"username": 'root', "password": 'root'})
+    db.use("namepace_test", "database_test")
+
+    # Create a record in the person table
+    db.create(
+        "person",
+        {
+            "user": "me",
+            "password": "safe",
+            "marketing": True,
+            "tags": ["python", "documentation"],
+        },
+    )
+
+    # Read all the records in the table
+    print(db.select("person"))
+
+    # Update all records in the table
+    print(db.update("person", {
+        "user":"you",
+        "password":"very_safe",
+        "marketing": False,
+        "tags": ["Awesome"]
+    }))
+
+    # Delete all records in the table
+    print(db.delete("person"))
+
+    # You can also use the query method 
+    # doing all of the above and more in SurrealQl
+    
+    # In SurrealQL you can do a direct insert 
+    # and the table will be created if it doesn't exist
+    
+    # Create
+    db.query("""
+    insert into person {
+        user: 'me',
+        password: 'very_safe',
+        tags: ['python', 'documentation']
+    };
+    """)
+
+    # Read
+    print(db.query("select * from person"))
+    
+    # Update
+    print(db.query("""
+    update person content {
+        user: 'you',
+        password: 'more_safe',
+        tags: ['awesome']
+    };
+    """))
+
+    # Delete
+    print(db.query("delete person"))
+```

public/integrations/agent-rules/surrealdb-vector.mdc

@@ -0,0 +1,60 @@
+---
+description: This rule provides information for creating vector indexes and vector queries in SurrealDB
+alwaysApply: false
+---
+
+## HNSW Index
+
+### Examples
+
+```surql
+DEFINE INDEX hnsw_idx ON pts FIELDS point HNSW DIMENSION 4;
+```
+
+With specific distance function `EUCLIDEAN` and type `F64`. Other available types: F64, F32, I64, I32, I16.
+
+```surql
+DEFINE INDEX hnsw_idx ON pts FIELDS point HNSW DIMENSION 4 DIST EUCLIDEAN TYPE F64;
+```
+
+Full-table example:
+
+```surql
+DEFINE TABLE OVERWRITE document SCHEMALESS;
+DEFINE FIELD OVERWRITE embedding ON document TYPE array<float>;
+DEFINE INDEX OVERWRITE hnsw_idx_document ON document
+    FIELDS embedding
+    HNSW DIMENSION 384
+    DIST COSINE
+    TYPE F32
+    EFC 150 M 12 M0 24;
+```
+
+### Querying
+
+When using HNSW, the `<|10, 40|>` notation in the WHERE clause means you want the top 10, using an effort value of 40.
+
+For effort values, 40 is a default recommended value. 17 is very fast, but misses some results.
+
+```surql
+SELECT
+    *,
+    vector::distance::knn() AS dist
+FROM document
+WHERE embedding <|10, 40|> $vector;
+```
+
+The example above will use the distance function defined by the index. That's what `vector::distance::knn()` means.
+
+A more complex example, returning score and filtering by a threshold:
+
+```surql
+SELECT *, score
+FROM (
+    SELECT *, (1 - vector::distance::knn()) AS score
+    FROM document
+    WHERE embedding <|20,40|> $vector
+)
+WHERE score >= $threshold
+ORDER BY score DESC;
+```