sf-vector-sdk 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

{sf_vector_sdk-0.2.0.dist-info → sf_vector_sdk-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sf-vector-sdk
-Version: 0.2.0
+Version: 0.2.2
 Summary: Python SDK for the Vector Gateway service (embeddings and vector search)
 Requires-Python: >=3.11
 Requires-Dist: redis>=5.0.0
@@ -220,25 +220,42 @@ Type-safe embedding for known tool types (FlashCard, TestQuestion, etc.) with au
 |--------|-------------|
 | `embed_flashcard(data, metadata)` | Embed a flashcard, return request ID |
 | `embed_flashcard_and_wait(data, metadata, timeout)` | Embed and wait for result |
+| `embed_flashcard_batch(items)` | Embed batch of flashcards, return request ID |
+| `embed_flashcard_batch_and_wait(items, timeout)` | Embed batch and wait for result |
 | `embed_test_question(data, metadata)` | Embed a test question, return request ID |
 | `embed_test_question_and_wait(data, metadata, timeout)` | Embed and wait for result |
+| `embed_test_question_batch(items)` | Embed batch of test questions, return request ID |
+| `embed_test_question_batch_and_wait(items, timeout)` | Embed batch and wait for result |
 | `embed_spaced_test_question(data, metadata)` | Embed a spaced test question, return request ID |
 | `embed_spaced_test_question_and_wait(data, metadata, timeout)` | Embed and wait for result |
+| `embed_spaced_test_question_batch(items)` | Embed batch of spaced test questions, return request ID |
+| `embed_spaced_test_question_batch_and_wait(items, timeout)` | Embed batch and wait for result |
 | `embed_audio_recap(data, metadata)` | Embed an audio recap section, return request ID |
 | `embed_audio_recap_and_wait(data, metadata, timeout)` | Embed and wait for result |
+| `embed_audio_recap_batch(items)` | Embed batch of audio recaps, return request ID |
+| `embed_audio_recap_batch_and_wait(items, timeout)` | Embed batch and wait for result |
+| `embed_topic(data, metadata)` | Embed a topic (uses `TopicMetadata`), return request ID |
+| `embed_topic_and_wait(data, metadata, timeout)` | Embed and wait for result (uses `TopicMetadata`) |
+| `embed_topic_batch(items)` | Embed batch of topics (uses `TopicMetadata`), return request ID |
+| `embed_topic_batch_and_wait(items, timeout)` | Embed batch and wait for result (uses `TopicMetadata`) |
+
+**Metadata Types:**
+
+- `ToolMetadata` - For tools (FlashCard, TestQuestion, etc.) - requires `tool_id`
+- `TopicMetadata` - For topics only - all fields optional (`user_id`, `topic_id`)
 
 ```python
-from vector_sdk import VectorClient, ToolMetadata, TestQuestionInput
+from vector_sdk import VectorClient, ToolMetadata, TopicMetadata, TestQuestionInput
 
 client = VectorClient(redis_url="redis://localhost:6379")
 
-# Embed a flashcard - SDK handles text extraction, hashing, and routing
+# Embed a flashcard - uses ToolMetadata (tool_id required)
 result = client.structured_embeddings.embed_flashcard_and_wait(
     data={"type": "BASIC", "term": "Mitochondria", "definition": "The powerhouse of the cell"},
     metadata=ToolMetadata(tool_id="tool123", user_id="user456", topic_id="topic789"),
 )
 
-# Embed a test question
+# Embed a test question - uses ToolMetadata (tool_id required)
 result = client.structured_embeddings.embed_test_question_and_wait(
     data=TestQuestionInput(
         question="What is the capital?",
@@ -247,6 +264,23 @@ result = client.structured_embeddings.embed_test_question_and_wait(
     ),
     metadata=ToolMetadata(tool_id="tool456"),
 )
+
+# Embed a topic - uses TopicMetadata (all fields optional)
+result = client.structured_embeddings.embed_topic_and_wait(
+    data={"topic": "Photosynthesis", "description": "The process by which plants convert sunlight to energy"},
+    metadata=TopicMetadata(user_id="user123", topic_id="topic456"),  # No tool_id needed
+)
+
+# Batch embedding - embed multiple topics in a single request
+from vector_sdk import TopicBatchItem
+
+batch_result = client.structured_embeddings.embed_topic_batch_and_wait(
+    items=[
+        TopicBatchItem(data={"topic": "Topic 1", "description": "Description 1"}, metadata=TopicMetadata(user_id="user1")),
+        TopicBatchItem(data={"topic": "Topic 2", "description": "Description 2"}, metadata=TopicMetadata(topic_id="topic2")),
+        TopicBatchItem(data={"topic": "Topic 3", "description": "Description 3"}, metadata=TopicMetadata()),  # All optional
+    ],
+)
 ```
 
 **Database Routing:**

{sf_vector_sdk-0.2.0.dist-info → sf_vector_sdk-0.2.2.dist-info}/RECORD

@@ -1,27 +1,27 @@
-vector_sdk/__init__.py,sha256=Fq4Pqq-xbDX_4M_lQhw6DVXAggUB-bjscNrUk8GEk2o,6632
+vector_sdk/__init__.py,sha256=3VdEG4tOuwTAWVvx9J-rOTuVY5RM-7tHzdL-ZLxRCYI,6979
 vector_sdk/client.py,sha256=NQFGHyR1aM0UToRFy6e9Xm_v6mk0opqzKN8UlHu97n0,17186
 vector_sdk/content_types.py,sha256=krvFOR58iUZPfYlEVsk0sXD6_ANAFbxEBQGNpt1YPDU,7381
 vector_sdk/types.py,sha256=rQgA2z3ls21vY-DRPZgfmm8gYFkWJk1dQaJI-nbc0no,25514
-vector_sdk/generated/embedding_pipeline/content_types/v1/content_types_pb2.py,sha256=HOyqisydOUgjQ2yEcLdAuW4O46ghcL7W--Sykc9Iwzc,5962
+vector_sdk/generated/embedding_pipeline/content_types/v1/content_types_pb2.py,sha256=5dW14j_DyIPKCaFI2cxCKKtQoLMGtRqV3aiRZ8Utxw4,5962
 vector_sdk/generated/embedding_pipeline/content_types/v1/content_types_pb2.pyi,sha256=fOw6liHkiXSEyvEZ_QKexDUgFNhbemuGuk52hwQ5pnQ,6738
-vector_sdk/generated/embedding_pipeline/db/vectors/v1/vectors_pb2.py,sha256=xwujSU8GXborGSDgKoRHQq_DL5CA6YAGX8L_Om35lRc,7057
+vector_sdk/generated/embedding_pipeline/db/vectors/v1/vectors_pb2.py,sha256=nFmjLnJJh5H-t25FJ8oP7jLH-mAcuEw-EK0U-dYlgDI,7057
 vector_sdk/generated/embedding_pipeline/db/vectors/v1/vectors_pb2.pyi,sha256=lxZ27fReDhHv2mKDCiPvKpicXuJObZX2zpfVYuGTk3I,8068
-vector_sdk/generated/embedding_pipeline/query/v1/query_pb2.py,sha256=E7uzz9w9xQlGbe_ZfO2MN_H8B-xpyFkkyixlDfaoGv0,5579
+vector_sdk/generated/embedding_pipeline/query/v1/query_pb2.py,sha256=X0EIUHMCt9a0L5iVjQXkdi2zKi7xKwPbEUeU8gNPeTk,5579
 vector_sdk/generated/embedding_pipeline/query/v1/query_pb2.pyi,sha256=a-rWfFQVAdZM5jK1qHB0bUiuSo6brcB-zUIHQezi0I8,5598
-vector_sdk/generated/embedding_pipeline/tools/v1/tools_pb2.py,sha256=i2VcFAoa8xVFsiXTxseDnZwpwl6iYv4CgwNV18mHHqU,2266
-vector_sdk/generated/embedding_pipeline/tools/v1/tools_pb2.pyi,sha256=KlMGcmAOXgCxVUmtqlyir_fNyRan9Bm3VEv4yGsWgHk,1453
-vector_sdk/hash/__init__.py,sha256=xyy3ezP4o58IkfUr2Kk-YwuAVtNH5uUG6QyUIed4Psw,691
-vector_sdk/hash/hasher.py,sha256=BjQ5d-dhJy2Smo-dssss2JDHcIfHjsvf08O_1h7Dq2I,7976
-vector_sdk/hash/types.py,sha256=QWSmGhbNcYZsRPZKWxgHC-XBOf-OBtE3XMGoTb2hm9Y,1785
+vector_sdk/generated/embedding_pipeline/tools/v1/tools_pb2.py,sha256=cf4PCZK-OtfLMyCuac0XqpZ6MQxk2XH4cy3QRu1_i8I,3094
+vector_sdk/generated/embedding_pipeline/tools/v1/tools_pb2.pyi,sha256=WKj_iRAuhXMNH3a2tf5j-ERYE5HLKamJTcQXm88JjDo,2451
+vector_sdk/hash/__init__.py,sha256=if-8tGOPyGUZy0_joGH66moE0e5zzwSzfUeMqP_8QsU,723
+vector_sdk/hash/hasher.py,sha256=k5VSQB-T0TtBM5ipaVE_TQu_uiaiWNjOWSbByxjriwQ,8618
+vector_sdk/hash/types.py,sha256=RHDM-ob9cOHPGMI7tXqiN_ZRowTPSc3GYHf8terrd8U,1983
 vector_sdk/namespaces/__init__.py,sha256=S9dJfB39s2zjYOpFn9Fvf8bk7mLKcXk5aPatKOA-xO0,374
 vector_sdk/namespaces/base.py,sha256=lioZBcd43mijnN0JwTMMEpQ6whiAjaueTDAAIZS1JM0,1156
 vector_sdk/namespaces/db.py,sha256=a5sEHrfy1xAjRjyM9qfZxr3IznZVA8BnY5W1Hq5jr4I,7230
 vector_sdk/namespaces/embeddings.py,sha256=7hH0hvBAeDf-ypTtOzUAqzc3W6wci_dbt_ZPavcRVyU,8950
 vector_sdk/namespaces/search.py,sha256=bwtZ_rTiP6q-dg8oOM5YA6taDHSphO88aq7RSuzc-tQ,8894
-vector_sdk/structured/__init__.py,sha256=eRiH-V6U-TSl98peoGdsRQukTysW9ZhTsous0fwHU-I,1468
+vector_sdk/structured/__init__.py,sha256=ZUhrH_l7bX5vA78DSKqDucWhfhYmkDX-W_MPzo5J9JU,1758
 vector_sdk/structured/router.py,sha256=F3O1TYtbVFCPqVWCCYCt5QcRffX5WPlPQ7K3KlayooQ,5792
-vector_sdk/structured/structured_embeddings.py,sha256=Z93Bcf38fpk8jhQvXTeioxt-yyhtQXo1fMoUKqgVlus,13031
-vector_sdk/structured/tool_config.py,sha256=sv0mRNUcuPO9C8Oh0_Y52YTyakbLk6gjrBW0C04Jt_w,7462
-sf_vector_sdk-0.2.0.dist-info/METADATA,sha256=HA0KnQ9SAIRYk7M-g_IOn5o1y1yL7ISpQS0j_T7u0tw,13671
-sf_vector_sdk-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-sf_vector_sdk-0.2.0.dist-info/RECORD,,
+vector_sdk/structured/structured_embeddings.py,sha256=Z0enOHx4vdhxAs0sbk9B6XHtRjZSfeYbNbtbq9f8Hh8,37147
+vector_sdk/structured/tool_config.py,sha256=YJp-S2_mwoODHWaWJHnGJRaKXuuqbbm2dYHTum2BuG4,8138
+sf_vector_sdk-0.2.2.dist-info/METADATA,sha256=JTf4o16e5REDLegscjWMbJcvdLVxDUCrwdCEAcH4fgk,15915
+sf_vector_sdk-0.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+sf_vector_sdk-0.2.2.dist-info/RECORD,,

vector_sdk/__init__.py

@@ -70,6 +70,7 @@ from vector_sdk.hash import (
     MultipleChoiceOption,
     QuestionData,
     ToolCollection,
+    TopicData,
     compute_content_hash,
     extract_tool_text,
 )
@@ -89,15 +90,21 @@ from vector_sdk.namespaces import (
 # ============================================================================
 from vector_sdk.structured import (
     TOOL_CONFIGS,
+    AudioRecapBatchItem,
+    BatchItem,
     DatabaseRoutingError,
     DatabaseRoutingMode,
+    FlashCardBatchItem,
     PineconeToolConfig,
     QuestionType,
     StructuredEmbeddingsNamespace,
+    TestQuestionBatchItem,
     TestQuestionInput,
     ToolConfig,
     ToolDatabaseConfig,
     ToolMetadata,
+    TopicBatchItem,
+    TopicMetadata,
     TurboPufferToolConfig,
     build_storage_config,
     get_content_type,
@@ -159,7 +166,7 @@ from vector_sdk.types import (
     validate_model,
 )
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 
 __all__ = [
     # Clients (New API)
@@ -236,12 +243,21 @@ __all__ = [
     "FlashCardData",
     "QuestionData",
     "AudioRecapSectionData",
+    "TopicData",
     "MultipleChoiceOption",
     "AnswerObject",
     # Structured Embeddings
     "StructuredEmbeddingsNamespace",
     "ToolMetadata",
+    "TopicMetadata",
     "TestQuestionInput",
+    # Batch types
+    "BatchItem",
+    "FlashCardBatchItem",
+    "TestQuestionBatchItem",
+    "AudioRecapBatchItem",
+    "TopicBatchItem",
+    # Tool configuration
     "ToolConfig",
     "ToolDatabaseConfig",
     "TurboPufferToolConfig",

vector_sdk/generated/embedding_pipeline/content_types/v1/content_types_pb2.py

@@ -2,7 +2,7 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # NO CHECKED-IN PROTOBUF GENCODE
 # source: embedding_pipeline/content_types/v1/content_types.proto
-# Protobuf Python Version: 6.33.4
+# Protobuf Python Version: 6.33.5
 """Generated protocol buffer code."""
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import descriptor_pool as _descriptor_pool
@@ -13,7 +13,7 @@ _runtime_version.ValidateProtobufRuntimeVersion(
     _runtime_version.Domain.PUBLIC,
     6,
     33,
-    4,
+    5,
     '',
     'embedding_pipeline/content_types/v1/content_types.proto'
 )

vector_sdk/generated/embedding_pipeline/db/vectors/v1/vectors_pb2.py

@@ -2,7 +2,7 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # NO CHECKED-IN PROTOBUF GENCODE
 # source: embedding_pipeline/db/vectors/v1/vectors.proto
-# Protobuf Python Version: 6.33.4
+# Protobuf Python Version: 6.33.5
 """Generated protocol buffer code."""
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import descriptor_pool as _descriptor_pool
@@ -13,7 +13,7 @@ _runtime_version.ValidateProtobufRuntimeVersion(
     _runtime_version.Domain.PUBLIC,
     6,
     33,
-    4,
+    5,
     '',
     'embedding_pipeline/db/vectors/v1/vectors.proto'
 )

vector_sdk/generated/embedding_pipeline/query/v1/query_pb2.py

@@ -2,7 +2,7 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # NO CHECKED-IN PROTOBUF GENCODE
 # source: embedding_pipeline/query/v1/query.proto
-# Protobuf Python Version: 6.33.4
+# Protobuf Python Version: 6.33.5
 """Generated protocol buffer code."""
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import descriptor_pool as _descriptor_pool
@@ -13,7 +13,7 @@ _runtime_version.ValidateProtobufRuntimeVersion(
     _runtime_version.Domain.PUBLIC,
     6,
     33,
-    4,
+    5,
     '',
     'embedding_pipeline/query/v1/query.proto'
 )

vector_sdk/generated/embedding_pipeline/tools/v1/tools_pb2.py

@@ -2,7 +2,7 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # NO CHECKED-IN PROTOBUF GENCODE
 # source: embedding_pipeline/tools/v1/tools.proto
-# Protobuf Python Version: 6.33.4
+# Protobuf Python Version: 6.33.5
 """Generated protocol buffer code."""
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import descriptor_pool as _descriptor_pool
@@ -13,7 +13,7 @@ _runtime_version.ValidateProtobufRuntimeVersion(
     _runtime_version.Domain.PUBLIC,
     6,
     33,
-    4,
+    5,
     '',
     'embedding_pipeline/tools/v1/tools.proto'
 )
@@ -24,7 +24,7 @@ _sym_db = _symbol_database.Default()
 
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\'embedding_pipeline/tools/v1/tools.proto\x12\x1b\x65mbedding_pipeline.tools.v1*\xc9\x01\n\x0eToolCollection\x12\x1f\n\x1bTOOL_COLLECTION_UNSPECIFIED\x10\x00\x12\x1d\n\x19TOOL_COLLECTION_FLASHCARD\x10\x01\x12!\n\x1dTOOL_COLLECTION_TEST_QUESTION\x10\x02\x12(\n$TOOL_COLLECTION_SPACED_TEST_QUESTION\x10\x03\x12*\n&TOOL_COLLECTION_AUDIO_RECAP_V2_SECTION\x10\x04*\xb2\x01\n\rFlashCardType\x12\x1f\n\x1b\x46LASH_CARD_TYPE_UNSPECIFIED\x10\x00\x12\x19\n\x15\x46LASH_CARD_TYPE_BASIC\x10\x01\x12\x19\n\x15\x46LASH_CARD_TYPE_CLOZE\x10\x02\x12%\n!FLASH_CARD_TYPE_FILL_IN_THE_BLANK\x10\x03\x12#\n\x1f\x46LASH_CARD_TYPE_MULTIPLE_CHOICE\x10\x04\x42gZegithub.com/GoStudyFetchGo/vector-management-monorepo/packages/go/proto-go/embedding_pipeline/tools/v1b\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\'embedding_pipeline/tools/v1/tools.proto\x12\x1b\x65mbedding_pipeline.tools.v1\"\xed\x01\n\rTopicMetadata\x12\x1c\n\x07user_id\x18\x01 \x01(\tH\x00R\x06userId\x88\x01\x01\x12\x1e\n\x08topic_id\x18\x02 \x01(\tH\x01R\x07topicId\x88\x01\x01\x12K\n\x05\x65xtra\x18\x03 \x03(\x0b\x32\x35.embedding_pipeline.tools.v1.TopicMetadata.ExtraEntryR\x05\x65xtra\x1a\x38\n\nExtraEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\n\n\x08_user_idB\x0b\n\t_topic_id*\xe4\x01\n\x0eToolCollection\x12\x1f\n\x1bTOOL_COLLECTION_UNSPECIFIED\x10\x00\x12\x1d\n\x19TOOL_COLLECTION_FLASHCARD\x10\x01\x12!\n\x1dTOOL_COLLECTION_TEST_QUESTION\x10\x02\x12(\n$TOOL_COLLECTION_SPACED_TEST_QUESTION\x10\x03\x12*\n&TOOL_COLLECTION_AUDIO_RECAP_V2_SECTION\x10\x04\x12\x19\n\x15TOOL_COLLECTION_TOPIC\x10\x05*\xb2\x01\n\rFlashCardType\x12\x1f\n\x1b\x46LASH_CARD_TYPE_UNSPECIFIED\x10\x00\x12\x19\n\x15\x46LASH_CARD_TYPE_BASIC\x10\x01\x12\x19\n\x15\x46LASH_CARD_TYPE_CLOZE\x10\x02\x12%\n!FLASH_CARD_TYPE_FILL_IN_THE_BLANK\x10\x03\x12#\n\x1f\x46LASH_CARD_TYPE_MULTIPLE_CHOICE\x10\x04\x42gZegithub.com/GoStudyFetchGo/vector-management-monorepo/packages/go/proto-go/embedding_pipeline/tools/v1b\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
@@ -32,8 +32,14 @@ _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'embedding_pipeline.tools.v1
 if not _descriptor._USE_C_DESCRIPTORS:
   _globals['DESCRIPTOR']._loaded_options = None
   _globals['DESCRIPTOR']._serialized_options = b'Zegithub.com/GoStudyFetchGo/vector-management-monorepo/packages/go/proto-go/embedding_pipeline/tools/v1'
-  _globals['_TOOLCOLLECTION']._serialized_start=73
-  _globals['_TOOLCOLLECTION']._serialized_end=274
-  _globals['_FLASHCARDTYPE']._serialized_start=277
-  _globals['_FLASHCARDTYPE']._serialized_end=455
+  _globals['_TOPICMETADATA_EXTRAENTRY']._loaded_options = None
+  _globals['_TOPICMETADATA_EXTRAENTRY']._serialized_options = b'8\001'
+  _globals['_TOOLCOLLECTION']._serialized_start=313
+  _globals['_TOOLCOLLECTION']._serialized_end=541
+  _globals['_FLASHCARDTYPE']._serialized_start=544
+  _globals['_FLASHCARDTYPE']._serialized_end=722
+  _globals['_TOPICMETADATA']._serialized_start=73
+  _globals['_TOPICMETADATA']._serialized_end=310
+  _globals['_TOPICMETADATA_EXTRAENTRY']._serialized_start=229
+  _globals['_TOPICMETADATA_EXTRAENTRY']._serialized_end=285
 # @@protoc_insertion_point(module_scope)

vector_sdk/generated/embedding_pipeline/tools/v1/tools_pb2.pyi

@@ -1,6 +1,9 @@
+from google.protobuf.internal import containers as _containers
 from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
 from google.protobuf import descriptor as _descriptor
-from typing import ClassVar as _ClassVar
+from google.protobuf import message as _message
+from collections.abc import Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional
 
 DESCRIPTOR: _descriptor.FileDescriptor
 
@@ -11,6 +14,7 @@ class ToolCollection(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
     TOOL_COLLECTION_TEST_QUESTION: _ClassVar[ToolCollection]
     TOOL_COLLECTION_SPACED_TEST_QUESTION: _ClassVar[ToolCollection]
     TOOL_COLLECTION_AUDIO_RECAP_V2_SECTION: _ClassVar[ToolCollection]
+    TOOL_COLLECTION_TOPIC: _ClassVar[ToolCollection]
 
 class FlashCardType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
     __slots__ = ()
@@ -24,8 +28,26 @@ TOOL_COLLECTION_FLASHCARD: ToolCollection
 TOOL_COLLECTION_TEST_QUESTION: ToolCollection
 TOOL_COLLECTION_SPACED_TEST_QUESTION: ToolCollection
 TOOL_COLLECTION_AUDIO_RECAP_V2_SECTION: ToolCollection
+TOOL_COLLECTION_TOPIC: ToolCollection
 FLASH_CARD_TYPE_UNSPECIFIED: FlashCardType
 FLASH_CARD_TYPE_BASIC: FlashCardType
 FLASH_CARD_TYPE_CLOZE: FlashCardType
 FLASH_CARD_TYPE_FILL_IN_THE_BLANK: FlashCardType
 FLASH_CARD_TYPE_MULTIPLE_CHOICE: FlashCardType
+
+class TopicMetadata(_message.Message):
+    __slots__ = ("user_id", "topic_id", "extra")
+    class ExtraEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: str
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ...
+    USER_ID_FIELD_NUMBER: _ClassVar[int]
+    TOPIC_ID_FIELD_NUMBER: _ClassVar[int]
+    EXTRA_FIELD_NUMBER: _ClassVar[int]
+    user_id: str
+    topic_id: str
+    extra: _containers.ScalarMap[str, str]
+    def __init__(self, user_id: _Optional[str] = ..., topic_id: _Optional[str] = ..., extra: _Optional[_Mapping[str, str]] = ...) -> None: ...

vector_sdk/hash/__init__.py

@@ -16,6 +16,7 @@ from .types import (
     MultipleChoiceOption,
     QuestionData,
     ToolCollection,
+    TopicData,
 )
 
 __all__ = [
@@ -26,6 +27,7 @@ __all__ = [
     "FlashCardData",
     "QuestionData",
     "AudioRecapSectionData",
+    "TopicData",
     "MultipleChoiceOption",
     "AnswerObject",
 ]

vector_sdk/hash/hasher.py

@@ -15,6 +15,7 @@ from .types import (
     MultipleChoiceOption,
     QuestionData,
     ToolCollection,
+    TopicData,
 )
 
 # Hash length in hex characters (128 bits = 32 hex chars)
@@ -23,7 +24,7 @@ HASH_LENGTH = 32
 
 def compute_content_hash(
     tool_collection: ToolCollection,
-    data: Union[FlashCardData, QuestionData, AudioRecapSectionData, dict],
+    data: Union[FlashCardData, QuestionData, AudioRecapSectionData, TopicData, dict],
 ) -> str:
     """
     Compute a deterministic content hash for a learning tool.
@@ -52,7 +53,7 @@ def compute_content_hash(
 
 def extract_tool_text(
     tool_collection: ToolCollection,
-    data: Union[FlashCardData, QuestionData, AudioRecapSectionData, dict],
+    data: Union[FlashCardData, QuestionData, AudioRecapSectionData, TopicData, dict],
 ) -> str:
     """
     Extract the text content from a learning tool for embedding.
@@ -94,6 +95,8 @@ def extract_tool_text(
         return _extract_question_text(data_dict)
     elif tool_collection == "AudioRecapV2Section":
         return _extract_audio_recap_text(data_dict)
+    elif tool_collection == "Topic":
+        return _extract_topic_text(data_dict)
     else:
         return ""
 
@@ -183,6 +186,29 @@ def _extract_audio_recap_text(data: dict) -> str:
     return ""
 
 
+def _extract_topic_text(data: dict) -> str:
+    """
+    Extract text from Topic.
+
+    Format: "Topic: {topic}. Description: {description}."
+    """
+    parts: list[str] = []
+
+    topic = data.get("topic")
+    if topic:
+        trimmed = topic.strip()
+        if trimmed:
+            parts.append(f"Topic: {trimmed}.")
+
+    description = data.get("description")
+    if description:
+        trimmed = description.strip()
+        if trimmed:
+            parts.append(f"Description: {trimmed}.")
+
+    return " ".join(parts)
+
+
 def _strip_flashcard_syntax(text: str) -> str:
     """
     Strip {{...}} markers from cloze/fill-in-blank text.

vector_sdk/hash/types.py

@@ -9,7 +9,7 @@ from typing import Literal, Optional, Union
 from pydantic import BaseModel, ConfigDict, Field
 
 # Tool collection types
-ToolCollection = Literal["FlashCard", "TestQuestion", "SpacedTestQuestion", "AudioRecapV2Section"]
+ToolCollection = Literal["FlashCard", "TestQuestion", "SpacedTestQuestion", "AudioRecapV2Section", "Topic"]
 
 # FlashCard type variants
 FlashCardType = Literal["BASIC", "CLOZE", "FILL_IN_THE_BLANK", "MULTIPLE_CHOICE"]
@@ -65,3 +65,12 @@ class AudioRecapSectionData(BaseModel):
     model_config = ConfigDict(extra="allow")
 
     script: Optional[str] = None
+
+
+class TopicData(BaseModel):
+    """Topic data for content hashing."""
+
+    model_config = ConfigDict(extra="allow")
+
+    topic: Optional[str] = None
+    description: Optional[str] = None

vector_sdk/structured/__init__.py

@@ -14,9 +14,15 @@ from .router import (
     validate_database_routing,
 )
 from .structured_embeddings import (
+    AudioRecapBatchItem,
+    BatchItem,
+    FlashCardBatchItem,
     StructuredEmbeddingsNamespace,
+    TestQuestionBatchItem,
     TestQuestionInput,
     ToolMetadata,
+    TopicBatchItem,
+    TopicMetadata,
 )
 from .tool_config import (
     TOOL_CONFIGS,
@@ -37,7 +43,14 @@ __all__ = [
     "StructuredEmbeddingsNamespace",
     # Types
     "ToolMetadata",
+    "TopicMetadata",
     "TestQuestionInput",
+    # Batch types
+    "BatchItem",
+    "FlashCardBatchItem",
+    "TestQuestionBatchItem",
+    "AudioRecapBatchItem",
+    "TopicBatchItem",
     # Tool configuration
     "ToolConfig",
     "ToolDatabaseConfig",

vector_sdk/structured/structured_embeddings.py

@@ -12,6 +12,7 @@ from ..hash import (
     AudioRecapSectionData,
     FlashCardData,
     ToolCollection,
+    TopicData,
     compute_content_hash,
     extract_tool_text,
 )
@@ -47,6 +48,29 @@ class ToolMetadata:
         return result
 
 
+@dataclass
+class TopicMetadata:
+    """
+    Metadata for topic embeddings.
+    Unlike ToolMetadata, all fields are optional since topics don't have a toolId.
+    """
+
+    user_id: Optional[str] = None
+    topic_id: Optional[str] = None
+    extra: Optional[dict[str, Any]] = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for document storage."""
+        result: dict[str, Any] = {}
+        if self.user_id:
+            result["userId"] = self.user_id
+        if self.topic_id:
+            result["topicId"] = self.topic_id
+        if self.extra:
+            result.update(self.extra)
+        return result
+
+
 @dataclass
 class TestQuestionInput:
     """Extended question data with question type."""
@@ -67,6 +91,46 @@ class TestQuestionInput:
         return result
 
 
+@dataclass
+class BatchItem:
+    """Batch item for embedding multiple items of the same type."""
+
+    data: dict[str, Any]
+    metadata: ToolMetadata
+
+
+@dataclass
+class FlashCardBatchItem:
+    """Batch item for FlashCard embeddings."""
+
+    data: FlashCardData
+    metadata: ToolMetadata
+
+
+@dataclass
+class TestQuestionBatchItem:
+    """Batch item for TestQuestion embeddings."""
+
+    data: TestQuestionInput
+    metadata: ToolMetadata
+
+
+@dataclass
+class AudioRecapBatchItem:
+    """Batch item for AudioRecap embeddings."""
+
+    data: AudioRecapSectionData
+    metadata: ToolMetadata
+
+
+@dataclass
+class TopicBatchItem:
+    """Batch item for Topic embeddings."""
+
+    data: TopicData
+    metadata: TopicMetadata
+
+
 # ============================================================================
 # StructuredEmbeddingsNamespace
 # ============================================================================
@@ -150,6 +214,61 @@ class StructuredEmbeddingsNamespace(BaseNamespace):
         card_type = data.get("type")
         return self._embed_tool_and_wait("FlashCard", data, metadata, card_type, timeout)
 
+    def embed_flashcard_batch(
+        self,
+        items: list[FlashCardBatchItem],
+    ) -> str:
+        """
+        Embed a batch of flashcards and return the request ID.
+        All flashcards in the batch should have the same type for proper namespace routing.
+
+        Args:
+            items: List of FlashCardBatchItem objects
+
+        Returns:
+            The request ID
+        """
+        return self._embed_tool_batch(
+            "FlashCard",
+            [
+                {
+                    "data": item.data,
+                    "metadata": item.metadata,
+                    "sub_type": item.data.get("type") if isinstance(item.data, dict) else None,
+                }
+                for item in items
+            ],
+        )
+
+    def embed_flashcard_batch_and_wait(
+        self,
+        items: list[FlashCardBatchItem],
+        timeout: int = 60,
+    ) -> EmbeddingResult:
+        """
+        Embed a batch of flashcards and wait for the result.
+        All flashcards in the batch should have the same type for proper namespace routing.
+
+        Args:
+            items: List of FlashCardBatchItem objects
+            timeout: Timeout in seconds (default: 60)
+
+        Returns:
+            The embedding result
+        """
+        return self._embed_tool_batch_and_wait(
+            "FlashCard",
+            [
+                {
+                    "data": item.data,
+                    "metadata": item.metadata,
+                    "sub_type": item.data.get("type") if isinstance(item.data, dict) else None,
+                }
+                for item in items
+            ],
+            timeout,
+        )
+
     # ==========================================================================
     # TestQuestion Methods
     # ==========================================================================
@@ -201,6 +320,61 @@ class StructuredEmbeddingsNamespace(BaseNamespace):
             timeout,
         )
 
+    def embed_test_question_batch(
+        self,
+        items: list[TestQuestionBatchItem],
+    ) -> str:
+        """
+        Embed a batch of test questions and return the request ID.
+        All questions in the batch should have the same question_type for proper namespace routing.
+
+        Args:
+            items: List of TestQuestionBatchItem objects
+
+        Returns:
+            The request ID
+        """
+        return self._embed_tool_batch(
+            "TestQuestion",
+            [
+                {
+                    "data": item.data.to_question_data(),
+                    "metadata": item.metadata,
+                    "sub_type": item.data.question_type,
+                }
+                for item in items
+            ],
+        )
+
+    def embed_test_question_batch_and_wait(
+        self,
+        items: list[TestQuestionBatchItem],
+        timeout: int = 60,
+    ) -> EmbeddingResult:
+        """
+        Embed a batch of test questions and wait for the result.
+        All questions in the batch should have the same question_type for proper namespace routing.
+
+        Args:
+            items: List of TestQuestionBatchItem objects
+            timeout: Timeout in seconds (default: 60)
+
+        Returns:
+            The embedding result
+        """
+        return self._embed_tool_batch_and_wait(
+            "TestQuestion",
+            [
+                {
+                    "data": item.data.to_question_data(),
+                    "metadata": item.metadata,
+                    "sub_type": item.data.question_type,
+                }
+                for item in items
+            ],
+            timeout,
+        )
+
     # ==========================================================================
     # SpacedTestQuestion Methods
     # ==========================================================================
@@ -252,6 +426,61 @@ class StructuredEmbeddingsNamespace(BaseNamespace):
             timeout,
         )
 
+    def embed_spaced_test_question_batch(
+        self,
+        items: list[TestQuestionBatchItem],
+    ) -> str:
+        """
+        Embed a batch of spaced test questions and return the request ID.
+        All questions in the batch should have the same question_type for proper namespace routing.
+
+        Args:
+            items: List of TestQuestionBatchItem objects
+
+        Returns:
+            The request ID
+        """
+        return self._embed_tool_batch(
+            "SpacedTestQuestion",
+            [
+                {
+                    "data": item.data.to_question_data(),
+                    "metadata": item.metadata,
+                    "sub_type": item.data.question_type,
+                }
+                for item in items
+            ],
+        )
+
+    def embed_spaced_test_question_batch_and_wait(
+        self,
+        items: list[TestQuestionBatchItem],
+        timeout: int = 60,
+    ) -> EmbeddingResult:
+        """
+        Embed a batch of spaced test questions and wait for the result.
+        All questions in the batch should have the same question_type for proper namespace routing.
+
+        Args:
+            items: List of TestQuestionBatchItem objects
+            timeout: Timeout in seconds (default: 60)
+
+        Returns:
+            The embedding result
+        """
+        return self._embed_tool_batch_and_wait(
+            "SpacedTestQuestion",
+            [
+                {
+                    "data": item.data.to_question_data(),
+                    "metadata": item.metadata,
+                    "sub_type": item.data.question_type,
+                }
+                for item in items
+            ],
+            timeout,
+        )
+
     # ==========================================================================
     # AudioRecap Methods
     # ==========================================================================
@@ -298,6 +527,401 @@ class StructuredEmbeddingsNamespace(BaseNamespace):
             timeout,
         )
 
+    def embed_audio_recap_batch(
+        self,
+        items: list[AudioRecapBatchItem],
+    ) -> str:
+        """
+        Embed a batch of audio recap sections and return the request ID.
+
+        Args:
+            items: List of AudioRecapBatchItem objects
+
+        Returns:
+            The request ID
+        """
+        return self._embed_tool_batch(
+            "AudioRecapV2Section",
+            [
+                {
+                    "data": item.data,
+                    "metadata": item.metadata,
+                    "sub_type": None,
+                }
+                for item in items
+            ],
+        )
+
+    def embed_audio_recap_batch_and_wait(
+        self,
+        items: list[AudioRecapBatchItem],
+        timeout: int = 60,
+    ) -> EmbeddingResult:
+        """
+        Embed a batch of audio recap sections and wait for the result.
+
+        Args:
+            items: List of AudioRecapBatchItem objects
+            timeout: Timeout in seconds (default: 60)
+
+        Returns:
+            The embedding result
+        """
+        return self._embed_tool_batch_and_wait(
+            "AudioRecapV2Section",
+            [
+                {
+                    "data": item.data,
+                    "metadata": item.metadata,
+                    "sub_type": None,
+                }
+                for item in items
+            ],
+            timeout,
+        )
+
+    # ==========================================================================
+    # Topic Methods
+    # ==========================================================================
+
+    def embed_topic(
+        self,
+        data: TopicData,
+        metadata: TopicMetadata,
+    ) -> str:
+        """
+        Embed a topic and return the request ID.
+
+        Args:
+            data: Topic data (topic, description)
+            metadata: Topic metadata (all fields optional)
+
+        Returns:
+            The request ID
+        """
+        return self._embed_topic_internal("Topic", data, metadata, None)
+
+    def embed_topic_and_wait(
+        self,
+        data: TopicData,
+        metadata: TopicMetadata,
+        timeout: int = 60,
+    ) -> EmbeddingResult:
+        """
+        Embed a topic and wait for the result.
+
+        Args:
+            data: Topic data
+            metadata: Topic metadata (all fields optional)
+            timeout: Timeout in seconds (default: 60)
+
+        Returns:
+            The embedding result
+        """
+        return self._embed_topic_internal_and_wait("Topic", data, metadata, None, timeout)
+
+    def embed_topic_batch(
+        self,
+        items: list[TopicBatchItem],
+    ) -> str:
+        """
+        Embed a batch of topics and return the request ID.
+
+        Args:
+            items: List of TopicBatchItem objects
+
+        Returns:
+            The request ID
+        """
+        return self._embed_topic_batch_internal(items)
+
+    def embed_topic_batch_and_wait(
+        self,
+        items: list[TopicBatchItem],
+        timeout: int = 60,
+    ) -> EmbeddingResult:
+        """
+        Embed a batch of topics and wait for the result.
+
+        Args:
+            items: List of TopicBatchItem objects
+            timeout: Timeout in seconds (default: 60)
+
+        Returns:
+            The embedding result
+        """
+        return self._embed_topic_batch_internal_and_wait(items, timeout)
+
+    # ==========================================================================
+    # Internal Topic Methods (using TopicMetadata)
+    # ==========================================================================
+
+    def _embed_topic_internal(
+        self,
+        tool_collection: ToolCollection,
+        data: TopicData,
+        metadata: TopicMetadata,
+        sub_type: Optional[str],
+    ) -> str:
+        """Internal method to embed a topic with TopicMetadata."""
+        # 1. Extract text using the spec
+        text = extract_tool_text({"toolCollection": tool_collection, "data": data})
+        if not text:
+            raise ValueError(
+                f"Failed to extract text from {tool_collection} - empty content"
+            )
+
+        # 2. Compute content hash
+        content_hash = compute_content_hash(
+            {"toolCollection": tool_collection, "data": data}
+        )
+        if not content_hash:
+            raise ValueError(
+                f"Failed to compute content hash for {tool_collection} - empty content"
+            )
+
+        # 3. Get tool config
+        tool_config = get_tool_config(tool_collection)
+
+        # 4. Build document with metadata (TopicMetadata doesn't have toolId)
+        document = {
+            **metadata.to_dict(),
+            "toolCollection": tool_collection,
+            "contentHash": content_hash,
+        }
+
+        # 5. Build storage config using router
+        storage_config = build_storage_config(
+            tool_collection=tool_collection,
+            sub_type=sub_type,
+            content_hash=content_hash,
+            document_fields=document,
+        )
+
+        # 6. Build text input
+        text_input = {
+            "id": content_hash,
+            "text": text,
+            "document": document,
+        }
+
+        # 7. Submit using embeddings namespace
+        return self._embeddings.create(
+            texts=[text_input],
+            content_type=get_content_type(tool_collection),
+            priority=tool_config.default_priority,
+            storage=storage_config,
+            metadata={
+                "toolCollection": tool_collection,
+                "contentHash": content_hash,
+            },
+            embedding_model=tool_config.model,
+            embedding_dimensions=tool_config.dimensions,
+        )
+
+    def _embed_topic_internal_and_wait(
+        self,
+        tool_collection: ToolCollection,
+        data: TopicData,
+        metadata: TopicMetadata,
+        sub_type: Optional[str],
+        timeout: int = 60,
+    ) -> EmbeddingResult:
+        """Internal method to embed a topic and wait for result."""
+        # 1. Extract text using the spec
+        text = extract_tool_text({"toolCollection": tool_collection, "data": data})
+        if not text:
+            raise ValueError(
+                f"Failed to extract text from {tool_collection} - empty content"
+            )
+
+        # 2. Compute content hash
+        content_hash = compute_content_hash(
+            {"toolCollection": tool_collection, "data": data}
+        )
+        if not content_hash:
+            raise ValueError(
+                f"Failed to compute content hash for {tool_collection} - empty content"
+            )
+
+        # 3. Get tool config
+        tool_config = get_tool_config(tool_collection)
+
+        # 4. Build document with metadata
+        document = {
+            **metadata.to_dict(),
+            "toolCollection": tool_collection,
+            "contentHash": content_hash,
+        }
+
+        # 5. Build storage config using router
+        storage_config = build_storage_config(
+            tool_collection=tool_collection,
+            sub_type=sub_type,
+            content_hash=content_hash,
+            document_fields=document,
+        )
+
+        # 6. Build text input
+        text_input = {
+            "id": content_hash,
+            "text": text,
+            "document": document,
+        }
+
+        # 7. Submit and wait using embeddings namespace
+        return self._embeddings.create_and_wait(
+            texts=[text_input],
+            content_type=get_content_type(tool_collection),
+            priority=tool_config.default_priority,
+            storage=storage_config,
+            metadata={
+                "toolCollection": tool_collection,
+                "contentHash": content_hash,
+            },
+            embedding_model=tool_config.model,
+            embedding_dimensions=tool_config.dimensions,
+            timeout=timeout,
+        )
+
+    def _embed_topic_batch_internal(
+        self,
+        items: list[TopicBatchItem],
+    ) -> str:
+        """Internal method to embed a batch of topics."""
+        if not items:
+            raise ValueError("Batch cannot be empty")
+
+        tool_collection: ToolCollection = "Topic"
+        tool_config = get_tool_config(tool_collection)
+
+        # Process each item
+        text_inputs = []
+        for item in items:
+            data = item.data
+            metadata = item.metadata
+
+            # Extract text
+            text = extract_tool_text({"toolCollection": tool_collection, "data": data})
+            if not text:
+                raise ValueError(
+                    f"Failed to extract text from {tool_collection} - empty content"
+                )
+
+            # Compute content hash
+            content_hash = compute_content_hash(
+                {"toolCollection": tool_collection, "data": data}
+            )
+            if not content_hash:
+                raise ValueError(
+                    f"Failed to compute content hash for {tool_collection} - empty content"
+                )
+
+            # Build document with metadata (TopicMetadata doesn't have toolId)
+            document = {
+                **metadata.to_dict(),
+                "toolCollection": tool_collection,
+                "contentHash": content_hash,
+            }
+
+            text_inputs.append({
+                "id": content_hash,
+                "text": text,
+                "document": document,
+            })
+
+        # Build storage config using first item
+        storage_config = build_storage_config(
+            tool_collection=tool_collection,
+            sub_type=None,
+            content_hash=text_inputs[0]["id"],
+            document_fields=text_inputs[0]["document"],
+        )
+
+        # Submit batch to embeddings namespace
+        return self._embeddings.create(
+            texts=text_inputs,
+            content_type=get_content_type(tool_collection),
+            priority=tool_config.default_priority,
+            storage=storage_config,
+            metadata={
+                "toolCollection": tool_collection,
+                "batchSize": len(items),
+            },
+            embedding_model=tool_config.model,
+            embedding_dimensions=tool_config.dimensions,
+        )
+
+    def _embed_topic_batch_internal_and_wait(
+        self,
+        items: list[TopicBatchItem],
+        timeout: int = 60,
+    ) -> EmbeddingResult:
+        """Internal method to embed a batch of topics and wait for result."""
+        if not items:
+            raise ValueError("Batch cannot be empty")
+
+        tool_collection: ToolCollection = "Topic"
+        tool_config = get_tool_config(tool_collection)
+
+        # Process each item
+        text_inputs = []
+        for item in items:
+            data = item.data
+            metadata = item.metadata
+
+            # Extract text
+            text = extract_tool_text({"toolCollection": tool_collection, "data": data})
+            if not text:
+                raise ValueError(
+                    f"Failed to extract text from {tool_collection} - empty content"
+                )
+
+            # Compute content hash
+            content_hash = compute_content_hash(
+                {"toolCollection": tool_collection, "data": data}
+            )
+            if not content_hash:
+                raise ValueError(
+                    f"Failed to compute content hash for {tool_collection} - empty content"
+                )
+
+            # Build document with metadata
+            document = {
+                **metadata.to_dict(),
+                "toolCollection": tool_collection,
+                "contentHash": content_hash,
+            }
+
+            text_inputs.append({
+                "id": content_hash,
+                "text": text,
+                "document": document,
+            })
+
+        # Build storage config using first item
+        storage_config = build_storage_config(
+            tool_collection=tool_collection,
+            sub_type=None,
+            content_hash=text_inputs[0]["id"],
+            document_fields=text_inputs[0]["document"],
+        )
+
+        # Submit batch and wait
+        return self._embeddings.create_and_wait(
+            texts=text_inputs,
+            content_type=get_content_type(tool_collection),
+            priority=tool_config.default_priority,
+            storage=storage_config,
+            metadata={
+                "toolCollection": tool_collection,
+                "batchSize": len(items),
+            },
+            embedding_model=tool_config.model,
+            embedding_dimensions=tool_config.dimensions,
+            timeout=timeout,
+        )
+
     # ==========================================================================
     # Internal Methods
     # ==========================================================================
@@ -429,3 +1053,164 @@ class StructuredEmbeddingsNamespace(BaseNamespace):
             embedding_dimensions=tool_config.dimensions,
             timeout=timeout,
         )
+
+    def _embed_tool_batch(
+        self,
+        tool_collection: ToolCollection,
+        items: list[dict[str, Any]],
+    ) -> str:
+        """
+        Internal method to embed a batch of items of the same tool type.
+
+        Args:
+            tool_collection: The tool collection type
+            items: List of dicts with 'data', 'metadata', and optional 'sub_type' keys
+
+        Returns:
+            The request ID
+        """
+        if not items:
+            raise ValueError("Batch cannot be empty")
+
+        # Get tool config (same for all items)
+        tool_config = get_tool_config(tool_collection)
+
+        # Process each item
+        text_inputs = []
+        for item in items:
+            data = item["data"]
+            metadata = item["metadata"]
+
+            # Extract text
+            text = extract_tool_text({"toolCollection": tool_collection, "data": data})
+            if not text:
+                raise ValueError(
+                    f"Failed to extract text from {tool_collection} - empty content"
+                )
+
+            # Compute content hash
+            content_hash = compute_content_hash(
+                {"toolCollection": tool_collection, "data": data}
+            )
+            if not content_hash:
+                raise ValueError(
+                    f"Failed to compute content hash for {tool_collection} - empty content"
+                )
+
+            # Build document with metadata
+            document = {
+                **metadata.to_dict(),
+                "toolCollection": tool_collection,
+                "contentHash": content_hash,
+            }
+
+            text_inputs.append({
+                "id": content_hash,
+                "text": text,
+                "document": document,
+            })
+
+        # Build storage config using first item's sub_type
+        first_item = items[0]
+        storage_config = build_storage_config(
+            tool_collection=tool_collection,
+            sub_type=first_item.get("sub_type"),
+            content_hash=text_inputs[0]["id"],
+            document_fields=text_inputs[0]["document"],
+        )
+
+        # Submit batch to embeddings namespace
+        return self._embeddings.create(
+            texts=text_inputs,
+            content_type=get_content_type(tool_collection),
+            priority=tool_config.default_priority,
+            storage=storage_config,
+            metadata={
+                "toolCollection": tool_collection,
+                "batchSize": len(items),
+            },
+            embedding_model=tool_config.model,
+            embedding_dimensions=tool_config.dimensions,
+        )
+
+    def _embed_tool_batch_and_wait(
+        self,
+        tool_collection: ToolCollection,
+        items: list[dict[str, Any]],
+        timeout: int = 60,
+    ) -> EmbeddingResult:
+        """
+        Internal method to embed a batch of items and wait for result.
+
+        Args:
+            tool_collection: The tool collection type
+            items: List of dicts with 'data', 'metadata', and optional 'sub_type' keys
+            timeout: Timeout in seconds (default: 60)
+
+        Returns:
+            The embedding result
+        """
+        if not items:
+            raise ValueError("Batch cannot be empty")
+
+        # Get tool config (same for all items)
+        tool_config = get_tool_config(tool_collection)
+
+        # Process each item
+        text_inputs = []
+        for item in items:
+            data = item["data"]
+            metadata = item["metadata"]
+
+            # Extract text
+            text = extract_tool_text({"toolCollection": tool_collection, "data": data})
+            if not text:
+                raise ValueError(
+                    f"Failed to extract text from {tool_collection} - empty content"
+                )
+
+            # Compute content hash
+            content_hash = compute_content_hash(
+                {"toolCollection": tool_collection, "data": data}
+            )
+            if not content_hash:
+                raise ValueError(
+                    f"Failed to compute content hash for {tool_collection} - empty content"
+                )
+
+            # Build document with metadata
+            document = {
+                **metadata.to_dict(),
+                "toolCollection": tool_collection,
+                "contentHash": content_hash,
+            }
+
+            text_inputs.append({
+                "id": content_hash,
+                "text": text,
+                "document": document,
+            })
+
+        # Build storage config using first item's sub_type
+        first_item = items[0]
+        storage_config = build_storage_config(
+            tool_collection=tool_collection,
+            sub_type=first_item.get("sub_type"),
+            content_hash=text_inputs[0]["id"],
+            document_fields=text_inputs[0]["document"],
+        )
+
+        # Submit batch and wait
+        return self._embeddings.create_and_wait(
+            texts=text_inputs,
+            content_type=get_content_type(tool_collection),
+            priority=tool_config.default_priority,
+            storage=storage_config,
+            metadata={
+                "toolCollection": tool_collection,
+                "batchSize": len(items),
+            },
+            embedding_model=tool_config.model,
+            embedding_dimensions=tool_config.dimensions,
+            timeout=timeout,
+        )

vector_sdk/structured/tool_config.py

@@ -144,6 +144,25 @@ TOOL_CONFIGS: dict[ToolCollection, ToolConfig] = {
             namespace_pattern="audiorecapv2section",
         ),
     ),
+    "Topic": ToolConfig(
+        tool_collection="Topic",
+        model="gemini-embedding-001",
+        dimensions=3072,
+        default_priority=PRIORITY_NORMAL,
+        turbopuffer=TurboPufferToolConfig(
+            enabled=True,
+            id_field="contentHash",
+            metadata_fields=_DEFAULT_METADATA_FIELDS,
+            namespace_pattern="topic_vectors",
+        ),
+        pinecone=PineconeToolConfig(
+            enabled=False,
+            index_name="tool-vectors",
+            id_field="contentHash",
+            metadata_fields=_DEFAULT_METADATA_FIELDS,
+            namespace_pattern="topic_vectors",
+        ),
+    ),
 }
 
 
@@ -198,8 +217,8 @@ def get_turbopuffer_namespace(
     config = TOOL_CONFIGS[tool_collection]
     pattern = config.turbopuffer.namespace_pattern
 
-    # AudioRecapV2Section doesn't have sub-types
-    if tool_collection == "AudioRecapV2Section":
+    # AudioRecapV2Section and Topic don't have sub-types
+    if tool_collection in ("AudioRecapV2Section", "Topic"):
         return pattern
 
     # Derive the type suffix
@@ -228,8 +247,8 @@ def get_pinecone_namespace(
     config = TOOL_CONFIGS[tool_collection]
     pattern = config.pinecone.namespace_pattern
 
-    # AudioRecapV2Section doesn't have sub-types
-    if tool_collection == "AudioRecapV2Section":
+    # AudioRecapV2Section and Topic don't have sub-types
+    if tool_collection in ("AudioRecapV2Section", "Topic"):
         return pattern
 
     # Derive the type suffix