Index Types

from typeagent.knowpro.interfaces import ITermToSemanticRefIndex

async def size(self) -> int

async def get_terms(self) -> list[str]

async def add_term(
    self,
    term: str,
    semantic_ref_ordinal: SemanticRefOrdinal | ScoredSemanticRefOrdinal,
) -> str

async def lookup_term(self, term: str) -> list[ScoredSemanticRefOrdinal] | None

index = await storage.get_semantic_ref_index()

# Look up term
results = await index.lookup_term("machine learning")
if results:
    for scored_ref in results:
        semref = await semantic_refs.get_item(scored_ref.semantic_ref_ordinal)
        print(f"Score {scored_ref.score}: {semref.knowledge}")

async def remove_term(
    self,
    term: str,
    semantic_ref_ordinal: SemanticRefOrdinal
) -> None

async def clear(self) -> None

from typeagent.knowpro.interfaces import IPropertyToSemanticRefIndex

async def add_property(
    self,
    property_name: str,
    value: str,
    semantic_ref_ordinal: SemanticRefOrdinal | ScoredSemanticRefOrdinal,
) -> None

async def lookup_property(
    self,
    property_name: str,
    value: str
) -> list[ScoredSemanticRefOrdinal] | None

index = await storage.get_property_index()

# Find all entities with status="completed"
results = await index.lookup_property("status", "completed")
if results:
    print(f"Found {len(results)} completed items")

async def get_values(self) -> list[str]

from typeagent.knowpro.interfaces import ITimestampToTextRangeIndex

async def add_timestamp(
    self,
    message_ordinal: MessageOrdinal,
    timestamp: str
) -> bool

async def add_timestamps(
    self,
    message_timestamps: list[tuple[MessageOrdinal, str]]
) -> None

async def lookup_range(
    self,
    date_range: DateRange
) -> list[TimestampedTextRange]

from datetime import datetime, timezone
from typeagent.knowpro.interfaces import DateRange

index = await storage.get_timestamp_index()

# Find messages in March 2024
start = datetime(2024, 3, 1, tzinfo=timezone.utc)
end = datetime(2024, 4, 1, tzinfo=timezone.utc)

results = await index.lookup_range(DateRange(start, end))
print(f"Found {len(results)} messages in March 2024")

for ttr in results:
    print(f"  {ttr.timestamp}: message {ttr.range.start.message_ordinal}")

from typeagent.knowpro.interfaces import IMessageTextIndex

async def add_messages(
    self,
    messages: Iterable[TMessage],
) -> None

async def lookup_messages(
    self,
    message_text: str,
    max_matches: int | None = None,
    threshold_score: float | None = None,
) -> list[ScoredMessageOrdinal]

index = await storage.get_message_text_index()

# Semantic search
results = await index.lookup_messages(
    "database performance optimization",
    max_matches=10,
    threshold_score=0.7
)

for scored in results:
    msg = await messages.get_item(scored.message_ordinal)
    print(f"Score {scored.score:.3f}: {msg.text_chunks[0][:100]}...")

async def lookup_messages_in_subset(
    self,
    message_text: str,
    ordinals_to_search: list[MessageOrdinal],
    max_matches: int | None = None,
    threshold_score: float | None = None,
) -> list[ScoredMessageOrdinal]

from typeagent.knowpro.interfaces import ITermToRelatedTermsIndex

async def lookup_term(self, text: str) -> list[Term] | None

async def add_related_term(
    self,
    text: str,
    related_terms: Term | list[Term]
) -> None

from typeagent.knowpro.interfaces import Term

index = await storage.get_related_terms_index()
aliases = index.aliases

# Add synonyms
await aliases.add_related_term(
    "ML",
    [Term("machine learning"), Term("artificial intelligence", weight=0.8)]
)

# Look up
related = await aliases.lookup_term("ML")
if related:
    print(f"ML is related to: {[t.text for t in related]}")

async def add_terms(self, texts: list[str]) -> None

async def lookup_term(
    self,
    text: str,
    max_hits: int | None = None,
    min_score: float | None = None,
) -> list[Term]

index = await storage.get_related_terms_index()
fuzzy = index.fuzzy_index

if fuzzy:
    # Add terms
    await fuzzy.add_terms(["database", "SQL", "query", "index"])
    
    # Fuzzy lookup
    similar = await fuzzy.lookup_term("databse", max_hits=3)  # Typo
    for term in similar:
        print(f"Did you mean '{term.text}'? (score: {term.weight:.3f})")

from typeagent.knowpro.interfaces import IConversationThreads

async def add_thread(self, thread: Thread) -> None

async def lookup_thread(
    self,
    thread_description: str,
    max_matches: int | None = None,
    threshold_score: float | None = None,
) -> list[ScoredThreadOrdinal] | None

from typeagent.knowpro.interfaces import Thread, TextRange, TextLocation

threads = await storage.get_conversation_threads()

# Add thread
thread = Thread(
    description="Discussion about API design patterns",
    ranges=[
        TextRange(TextLocation(10, 0), TextLocation(15, 0)),
        TextRange(TextLocation(20, 0), TextLocation(22, 0))
    ]
)
await threads.add_thread(thread)

# Search threads
results = await threads.lookup_thread("REST API design")
if results:
    for scored in results:
        thread = threads.threads[scored.thread_ordinal]
        print(f"Score {scored.score:.3f}: {thread.description}")

from typeagent.knowpro.interfaces import IConversationSecondaryIndexes

conv = await create_conversation(dbname="chat.db", message_type=ConversationMessage)

indexes = conv.secondary_indexes
if indexes:
    if indexes.property_index:
        print("Property index available")
    if indexes.timestamp_index:
        print("Timestamp index available")
    if indexes.message_index:
        print("Message text search available")