Louie API Reference¶

from llamatelemetry.louie import (
    LouieClient, natural_query, extract_entities, extract_relationships,
    KnowledgeExtractor, build_knowledge_graph,
    EntityType, RelationType,
)

def query(
    self,
    question: str,
    context: Optional[str] = None,
    extract_graph: bool = True,
    max_tokens: int = 1000,
) -> QueryResult

client = LouieClient()
result = client.query(
    "Extract entities and relationships",
    context="Python is used for AI. TensorFlow is a Python library."
)
print(result.entities)
# [{"id": "Python", "type": "language"}, {"id": "TensorFlow", "type": "technology"}, ...]
print(result.relationships)
# [{"source": "Python", "target": "AI", "type": "used_for"}, ...]
if result.graph:
    result.graph.plot()

def extract(self, text: str, **kwargs) -> QueryResult

@dataclass
class QueryResult:
    text: str                              # LLM response text
    entities: List[Dict[str, Any]]         # Extracted entities
    relationships: List[Dict[str, Any]]    # Extracted relationships
    raw_response: str                      # Raw LLM output
    graph: Optional[Any] = None            # Graphistry graph object (if available)

def natural_query(
    question: str,
    context: Optional[str] = None,
    model: Optional[str] = None,
    **kwargs,
) -> QueryResult

from llamatelemetry.louie import natural_query
result = natural_query(
    "What are the main technologies?",
    context="Python and TensorFlow are used for machine learning."
)
print(result.text)

def extract_entities(
    text: str,
    model: Optional[str] = None,
    **kwargs,
) -> List[Dict[str, Any]]

from llamatelemetry.louie import extract_entities
entities = extract_entities("Python is a programming language.")
# [{"id": "Python", "type": "language", "properties": {}}]

def extract_relationships(
    text: str,
    model: Optional[str] = None,
    **kwargs,
) -> List[Dict[str, Any]]

from llamatelemetry.louie import extract_relationships
rels = extract_relationships("Python is used for AI development.")
# [{"source": "Python", "target": "AI", "type": "used_for"}]

def extract(
    self,
    text: str,
    max_entities: int = 50,
    max_relationships: int = 100,
    max_tokens: int = 2000,
) -> KnowledgeGraph

extractor = KnowledgeExtractor(model="gemma-3-1b-Q4_K_M")
kg = extractor.extract("""
    Python is a programming language created by Guido van Rossum.
    It is widely used for machine learning with libraries like TensorFlow.
""")
print(f"Entities: {len(kg.entities)}")
print(f"Relationships: {len(kg.relationships)}")
g = kg.to_graphistry()
g.plot()

def build_knowledge_graph(
    text: str,
    model: Optional[str] = None,
    **kwargs,
) -> KnowledgeGraph

from llamatelemetry.louie import build_knowledge_graph
kg = build_knowledge_graph("Python is used for data science. TensorFlow is popular.")
g = kg.to_graphistry()
g.plot()

class EntityType(Enum):
    PERSON = "person"
    ORGANIZATION = "organization"
    LOCATION = "location"
    CONCEPT = "concept"
    TECHNOLOGY = "technology"
    LANGUAGE = "language"
    PRODUCT = "product"
    EVENT = "event"
    DATE = "date"
    NUMBER = "number"
    OTHER = "other"

class RelationType(Enum):
    USES = "uses"
    CREATES = "creates"
    BELONGS_TO = "belongs_to"
    RELATED_TO = "related_to"
    PART_OF = "part_of"
    LOCATED_IN = "located_in"
    WORKS_FOR = "works_for"
    DEPENDS_ON = "depends_on"
    IMPLEMENTS = "implements"
    EXTENDS = "extends"
    CONTAINS = "contains"
    OTHER = "other"

@dataclass
class Entity:
    id: str                              # Entity identifier
    type: EntityType                     # Entity type enum
    properties: Dict[str, Any]           # Additional properties

def to_dict(self) -> Dict[str, Any]

@dataclass
class Relationship:
    source: str                          # Source entity ID
    target: str                          # Target entity ID
    type: RelationType                   # Relationship type enum
    weight: float = 1.0                  # Relationship strength (0.0 to 1.0)
    properties: Dict[str, Any]           # Additional properties

def to_dict(self) -> Dict[str, Any]

@dataclass
class KnowledgeGraph:
    entities: List[Entity]
    relationships: List[Relationship]
    metadata: Dict[str, Any]             # source_text_length, entity_count, relationship_count

def to_dict(self) -> Dict[str, Any]

def to_graphistry(self, gpu_id: int = 1) -> Any

kg = build_knowledge_graph("NVIDIA builds GPUs. CUDA runs on NVIDIA GPUs.")
graph = kg.to_graphistry(gpu_id=1)
graph.plot()  # Opens GPU-accelerated visualization

from llamatelemetry.louie import KnowledgeExtractor, EntityType, RelationType

# Extract with specific types
extractor = KnowledgeExtractor(
    entity_types=[EntityType.TECHNOLOGY, EntityType.LANGUAGE, EntityType.CONCEPT],
    relationship_types=[RelationType.USES, RelationType.IMPLEMENTS, RelationType.DEPENDS_ON],
)

kg = extractor.extract("""
    llamatelemetry is a Python SDK built on OpenTelemetry.
    It uses CUDA for GPU acceleration and llama.cpp for inference.
    The SDK supports GGUF models quantized with NF4 and Q4_K_M.
""")

# Inspect results
for entity in kg.entities:
    print(f"  {entity.type.value}: {entity.id}")

for rel in kg.relationships:
    print(f"  {rel.source} --{rel.type.value}--> {rel.target} (weight={rel.weight})")

# Visualize
g = kg.to_graphistry()
g.plot()