8954fa3ad7
Native CLI i18n: The TrustGraph CLI has built-in translation support that dynamically loads language strings. You can test and use different languages by simply passing the --lang flag (e.g., --lang es for Spanish, --lang ru for Russian) or by configuring your environment's LANG variable. Automated Docs Translations: This PR introduces autonomously translated Markdown documentation into several target languages, including Spanish, Swahili, Portuguese, Turkish, Hindi, Hebrew, Arabic, Simplified Chinese, and Russian.
104 KiB
| layout | title | parent |
|---|---|---|
| default | Marejeleo ya API ya Python ya TrustGraph | Swahili (Beta) |
Marejeleo ya API ya Python ya TrustGraph
Beta Translation: This document was translated via Machine Learning and as such may not be 100% accurate. All non-English languages are currently classified as Beta.
Ufungaji
pip install trustgraph
Kuanza Haraka
Madarasa na aina zote zinaingizwa kutoka kwenye kifurushi cha trustgraph.api:
from trustgraph.api import Api, Triple, ConfigKey
# Create API client
api = Api(url="http://localhost:8088/")
# Get a flow instance
flow = api.flow().id("default")
# Execute a graph RAG query
response = flow.graph_rag(
query="What are the main topics?",
user="trustgraph",
collection="default"
)
Jina la Yaliyomo
Msingi
Wateja wa Flow
Flow FlowInstance AsyncFlow AsyncFlowInstance
Wateja wa WebSocket
SocketClient SocketFlowInstance AsyncSocketClient AsyncSocketFlowInstance
Operesheni za Kiasi
Vipimo
Aina za Data
Triple ConfigKey ConfigValue DocumentMetadata ProcessingMetadata CollectionMetadata StreamingChunk AgentThought AgentObservation AgentAnswer RAGChunk
Vizuizi
ProtocolException TrustGraphException AgentError ConfigError DocumentRagError FlowError GatewayError GraphRagError LLMError LoadError LookupError NLPQueryError RowsQueryError RequestError StructuredQueryError UnexpectedError ApplicationException
--
Api
from trustgraph.api import Api
Mteja mkuu wa API ya TrustGraph kwa operesheni za synchronous na asynchronous.
Darasa hili hutoa ufikiaji kwa huduma zote za TrustGraph, pamoja na usimamizi wa mtiririko, operesheni za grafu ya maarifa, usindikaji wa hati, maswali ya RAG, na zaidi. Inasaidia mifumo ya mawasiliano ya msingi wa REST na WebSocket.
Mteja unaweza kutumika kama meneja wa muktadha kwa usafi wa kiotomatiki wa rasilimali:
python with Api(url="http://localhost:8088/") as api: result = api.flow().id("default").graph_rag(query="test")
Mbinu
__aenter__(self)
Ingia katika meneja wa muktadha wa asinkroni.
__aexit__(self, *args)
Ondoka katika meneja wa muktadha wa asinkroni na ufungue miunganisho.
__enter__(self)
Ingia katika meneja wa muktadha wa sinkroni.
__exit__(self, *args)
Ondoka katika meneja wa muktadha wa sinkroni na ufungue miunganisho.
__init__(self, url='http://localhost:8088/', timeout=60, token: str | None = None)
Anzisha mteja wa API ya TrustGraph.
Vigezo:
url: URL ya msingi kwa API ya TrustGraph (kiwango chachilia: "http://localhost:8088/"")
timeout: Muda wa kikao wa ombi katika sekunde (kiwango chachilia: 60)
token: Tokeni ya kuhudhuria ya hiari kwa uthibitishaji
Mfano:
# Local development
api = Api()
# Production with authentication
api = Api(
url="https://trustgraph.example.com/",
timeout=120,
token="your-api-token"
)
aclose(self)
Funga miunganisho yote ya mteja isiyo ya kawaida.
Njia hii inafunga miunganisho ya WebSocket isiyo ya kawaida, operesheni kubwa, na miunganisho ya mtiririko. Inaitwa kiotomatiki wakati wa kutoka katika meneja wa muktadha usio wa kawaida.
Mfano:
api = Api()
async_socket = api.async_socket()
# ... use async_socket
await api.aclose() # Clean up connections
# Or use async context manager (automatic cleanup)
async with Api() as api:
async_socket = api.async_socket()
# ... use async_socket
# Automatically closed
async_bulk(self)
Pata mteja wa operesheni za wingi zisizo za moja kwa moja.
Hutoa operesheni za uagizaji/uangamizi za wingi kwa mtindo wa async/await kupitia WebSocket kwa ajili ya usimamizi bora wa data kubwa.
Inarudisha: AsyncBulkClient: Mteja wa operesheni za wingi zisizo za moja kwa moja.
Mfano:
async_bulk = api.async_bulk()
# Export triples asynchronously
async for triple in async_bulk.export_triples(flow="default"):
print(f"{triple.s} {triple.p} {triple.o}")
# Import with async generator
async def triple_gen():
yield Triple(s="subj", p="pred", o="obj")
# ... more triples
await async_bulk.import_triples(
flow="default",
triples=triple_gen()
)
async_flow(self)
Pata mteja wa mtiririko (flow) unaotumia REST na unaoweza kufanya kazi bila kusubiri.
Hutoa ufikiaji wa operesheni za mtiririko kwa mtindo wa async/await. Hii inapendelewa kwa programu na mifumo ya Python inayotumia async (FastAPI, aiohttp, n.k.).
Inarudisha: AsyncFlow: Mteja wa mtiririko (flow) usiofanya kazi bila kusubiri.
Mfano:
async_flow = api.async_flow()
# List flows
flow_ids = await async_flow.list()
# Execute operations
instance = async_flow.id("default")
result = await instance.text_completion(
system="You are helpful",
prompt="Hello"
)
async_metrics(self)
Pata mteja wa metriki zisizo za moja kwa moja.
Hutoa ufikiaji wa mtindo wa async/await kwa metriki za Prometheus.
Inarudisha: AsyncMetrics: Mteja wa metriki zisizo za moja kwa moja.
Mfano:
async_metrics = api.async_metrics()
prometheus_text = await async_metrics.get()
print(prometheus_text)
async_socket(self)
Pata mteja wa WebSocket usio na utaratibu kwa operesheni za utiririshaji.
Hutoa ufikiaji wa WebSocket wa aina ya async/await pamoja na usaidizi wa utiririshaji. Hii ndiyo njia inayopendekezwa kwa utiririshaji usio na utaratibu katika Python.
Inarudisha: AsyncSocketClient: Mteja wa WebSocket usio na utaratibu.
Mfano:
async_socket = api.async_socket()
flow = async_socket.flow("default")
# Stream agent responses
async for chunk in flow.agent(
question="Explain quantum computing",
user="trustgraph",
streaming=True
):
if hasattr(chunk, 'content'):
print(chunk.content, end='', flush=True)
bulk(self)
Pata mteja wa shughuli za wingi za moja kwa moja kwa ajili ya uagizaji/utoaji.
Shughuli za wingi huruhusu uhamishaji wa ufanisi wa data kubwa kupitia muunganisho wa WebSocket, ikiwa ni pamoja na vitu vitatu, maandamano, muktadha wa vitu, na vitu.
Inarudisha: BulkClient: Mteja wa shughuli za wingi za moja kwa moja.
Mfano:
bulk = api.bulk()
# Export triples
for triple in bulk.export_triples(flow="default"):
print(f"{triple.s} {triple.p} {triple.o}")
# Import triples
def triple_generator():
yield Triple(s="subj", p="pred", o="obj")
# ... more triples
bulk.import_triples(flow="default", triples=triple_generator())
close(self)
Funga miunganisho yote ya mteja ya wakati huo.
Njia hii inafunga miunganisho ya WebSocket na miunganisho ya operesheni kubwa. Inaitwa kiotomatiki wakati wa kutoka katika meneja wa muktadha.
Mfano:
api = Api()
socket = api.socket()
# ... use socket
api.close() # Clean up connections
# Or use context manager (automatic cleanup)
with Api() as api:
socket = api.socket()
# ... use socket
# Automatically closed
collection(self)
Pata mteja wa Collection kwa ajili ya kusimamia makusanyo ya data.
Makusanyo huandaa hati na data ya mfumo wa maarifa katika vikundi vya mantiki kwa ajili ya kutenganisha na udhibiti wa ufikiaji.
Inarudisha: Collection: Mteja wa usimamizi wa Collection
Mfano:
collection = api.collection()
# List collections
colls = collection.list_collections(user="trustgraph")
# Update collection metadata
collection.update_collection(
user="trustgraph",
collection="default",
name="Default Collection",
description="Main data collection"
)
config(self)
Pata mteja wa Config kwa ajili ya kusimamia mipangilio.
Inarudisha: Config: Mteja wa usimamizi wa mipangilio.
Mfano:
config = api.config()
# Get configuration values
values = config.get([ConfigKey(type="llm", key="model")])
# Set configuration
config.put([ConfigValue(type="llm", key="model", value="gpt-4")])
flow(self)
Pata programu (client) ya Flow kwa ajili ya kusimamia na kuingiliana na michakato.
Michakato (Flows) ni vitengo vikuu vya utekelezaji katika TrustGraph, ikitoa ufikiaji kwa huduma kama vile wakala, maswali ya RAG, maandamano, na usindikaji wa nyaraka.
Inarudisha: Flow: Programu ya usimamizi wa Flow.
Mfano:
flow_client = api.flow()
# List available blueprints
blueprints = flow_client.list_blueprints()
# Get a specific flow instance
flow_instance = flow_client.id("default")
response = flow_instance.text_completion(
system="You are helpful",
prompt="Hello"
)
knowledge(self)
Pata mteja wa Knowledge kwa ajili ya kusimamia msingi wa grafu ya maarifa.
Inarudisha: Mteja wa usimamizi wa grafu ya maarifa: Knowledge
Mfano:
knowledge = api.knowledge()
# List available KG cores
cores = knowledge.list_kg_cores(user="trustgraph")
# Load a KG core
knowledge.load_kg_core(id="core-123", user="trustgraph")
library(self)
Pata mteja wa Maktaba kwa usimamizi wa nyaraka.
Maktaba hutoa uhifadhi wa nyaraka, usimamizi wa metadata, na uratibu wa mtiririko wa kazi.
Inarudisha: Library: Mteja wa usimamizi wa maktaba ya nyaraka.
Mfano:
library = api.library()
# Add a document
library.add_document(
document=b"Document content",
id="doc-123",
metadata=[],
user="trustgraph",
title="My Document",
comments="Test document"
)
# List documents
docs = library.get_documents(user="trustgraph")
metrics(self)
Pata mteja wa metriki wa moja kwa moja kwa ajili ya ufuatiliaji.
Hupata metriki zilizofunganishwa kwa muundo wa Prometheus kutoka kwa huduma ya TrustGraph kwa ajili ya ufuatiliaji na uwezeshaji.
Inarudisha: Metri: Mteja wa metriki wa moja kwa moja
Mfano:
metrics = api.metrics()
prometheus_text = metrics.get()
print(prometheus_text)
request(self, path, request)
Fanya ombi la API ya REST ya kiwango cha chini.
Njia hii hutumika hasa kwa matumizi ya ndani, lakini inaweza kutumika kwa ufikiaji wa moja kwa moja wa API wakati inahitajika.
Vigezo:
path: Njia ya mwisho ya API (kulingana na URL ya msingi)
request: Takwimu ya ombi kama kamusi
Inarudisha: dict: Kijisimu cha majibu
Inatirisha:
ProtocolException: Ikiwa hali ya majibu si 200 au majibu hayana umbizo la JSON
ApplicationException: Ikiwa majibu yana kosa
Mfano:
response = api.request("flow", {
"operation": "list-flows"
})
socket(self)
Pata mteja wa WebSocket wa aina ya moja kwa shughuli za utiririshaji.
Miunganisho ya WebSocket hutoa utiifu wa data kwa majibu ya muda halisi kutoka kwa wakala, maswali ya RAG, na kukamilisha maandishi. Njia hii inarudisha kifungashio cha aina ya moja kilichozunguka itifaki ya WebSocket.
Inarudisha: SocketClient: Mteja wa WebSocket wa aina ya moja.
Mfano:
socket = api.socket()
flow = socket.flow("default")
# Stream agent responses
for chunk in flow.agent(
question="Explain quantum computing",
user="trustgraph",
streaming=True
):
if hasattr(chunk, 'content'):
print(chunk.content, end='', flush=True)
--
Flow
from trustgraph.api import Flow
Mteja wa usimamizi wa mtiririko kwa operesheni za muundo na mfano wa mtiririko.
Darasa hili hutoa mbinu za kusimamia muundo wa mtiririko (vipengele) na mifano ya mtiririko (mitiririko inayoendelea). Vipengele vinafafanua muundo na vigezo vya mitiririko, wakati mifano inawakilisha mitiririko inayofanya kazi ambayo inaweza kutekeleza huduma.
Mbinu
__init__(self, api)
Anzisha mteja wa mtiririko.
Majadiliano:
api: Eneo la awali la Api kwa kutuma ombi.
delete_blueprint(self, blueprint_name)
Futa muundo wa mtiririko.
Majadiliano:
blueprint_name: Jina la muundo kufutwa.
Mfano:
api.flow().delete_blueprint("old-blueprint")
get(self, id)
Pata ufafanuzi wa mfano unaoendelea.
Vigezo:
id: Kitambulisho cha mfano.
Inarudisha: dict: Ufafanuzi wa mfano.
Mfano:
flow_def = api.flow().get("default")
print(flow_def)
get_blueprint(self, blueprint_name)
Pata ufafanuzi wa mpango (blueprint) kwa jina.
Vigezo:
blueprint_name: Jina la mpango (blueprint) ambao unataka kupata
Inarudisha: dict: Ufafanuzi wa mpango (blueprint) kama kamusi.
Mfano:
blueprint = api.flow().get_blueprint("default")
print(blueprint) # Blueprint configuration
id(self, id='default')
Pata FlowInstance ili kutekeleza shughuli kwenye mtiririko maalum.
Vigezo:
id: Kitambulisho cha mtiririko (cha kawaida: "default")
Inarudisha: FlowInstance: Mtiririko wa huduma kwa shughuli.
Mfano:
flow = api.flow().id("my-flow")
response = flow.text_completion(
system="You are helpful",
prompt="Hello"
)
list(self)
Orodha ya matukio yote yanayoendelea.
Inarudisha: list[str]: Orodha ya kitambulisho cha matukio.
Mfano:
flows = api.flow().list()
print(flows) # ['default', 'flow-1', 'flow-2', ...]
list_blueprints(self)
Orodha ya mipango yote ya mtiririko inayopatikana.
Inarudisha: list[str]: Orodha ya majina ya mipango
Mfano:
blueprints = api.flow().list_blueprints()
print(blueprints) # ['default', 'custom-flow', ...]
put_blueprint(self, blueprint_name, definition)
Kuunda au kusasisha mpango wa mtiririko.
Vigezo:
blueprint_name: Jina la mpango
definition: Kamusi ya ufafanuzi wa mpango
Mfano:
definition = {
"services": ["text-completion", "graph-rag"],
"parameters": {"model": "gpt-4"}
}
api.flow().put_blueprint("my-blueprint", definition)
request(self, path=None, request=None)
Fanya ombi la API katika eneo maalum.
Vigezo:
path: Ongeza ya hiari kwa njia za mwisho za eneo.
request: Kamusi ya data ya ombi.
Inarudisha: dict: Kitu kinachojibu.
Inayotokea:
RuntimeError: Ikiwa parameter ya ombi haijatolewa.
start(self, blueprint_name, id, description, parameters=None)
Anza eneo jipya kutoka kwa mpango.
Vigezo:
blueprint_name: Jina la mpango ambao utaanzishwa.
id: Kitambulisho cha kipekee kwa eneo.
description: Maelezo ambayo yanaweza kueleweka.
parameters: Vigezo vya hiari.
Mfano:
api.flow().start(
blueprint_name="default",
id="my-flow",
description="My custom flow",
parameters={"model": "gpt-4"}
)
stop(self, id)
Kusimamisha mfumo unaoendelea.
Vigezo:
id: Kitambulisho cha mfumo unaoendelea ili kusimamishwa.
Mfano:
api.flow().stop("my-flow")
--
FlowInstance
from trustgraph.api import FlowInstance
Mteja wa mfumo (flow) kwa kutekeleza huduma kwenye mfumo maalum.
Darasa hili hutoa ufikiaji kwa huduma zote za TrustGraph, pamoja na: Kukamilisha maandishi na uwekaji wa data (embeddings) Utendaji wa wakala (agent) pamoja na usimamizi wa hali (state) Ufuatiliaji wa maswali (queries) ya RAG kwa grafu na nyaraka Utendaji wa grafu ya maarifa (triples, vitu) Kupakua na kuchakata nyaraka Ubadilishaji wa lugha ya asili kuwa swali la GraphQL Uchambuzi wa data iliyopangwa na utambuzi wa muundo (schema) Utendaji wa zana ya MCP Ubunifu wa kigezo cha swali (prompt templating)
Huduma zinapatikana kupitia mfumo unaoendelea (flow instance) unaotambulika na kitambulisho (ID).
Mbinu (Methods)
__init__(self, api, id)
Anzisha FlowInstance.
Majadilisho:
api: Mteja wa mfumo (flow) wa juu.
id: Kitambulisho cha mfumo unaoendelea (flow instance).
agent(self, question, user='trustgraph', state=None, group=None, history=None)
Tekeleza utendaji wa wakala (agent) pamoja na uwezo wa kufikiri na kutumia zana.
Wakala wanaweza kufanya utafakari wa hatua nyingi, kutumia zana, na kudumisha mazungumzo hali katika mwingiliano. Hii ni toleo la moja kwa moja (synchronous) lisilo na utiririshaji (non-streaming).
Majadilisho:
question: Swali au maagizo ya mtumiaji.
user: Kitambulisho cha mtumiaji (default: "trustgraph")
state: Kamusi ya hali (state) ya hiari kwa mazungumzo yenye hali.
group: Kitambulisho cha kikundi cha hiari kwa muktadha wa watumiaji wengi.
history: Historia ya mazungumzo ya hiari kama orodha ya maneno ya kamusi.
Inarudisha: string: Jibu la mwisho la wakala.
Mfano:
flow = api.flow().id("default")
# Simple question
answer = flow.agent(
question="What is the capital of France?",
user="trustgraph"
)
# With conversation history
history = [
{"role": "user", "content": "Hello"},
{"role": "assistant", "content": "Hi! How can I help?"}
]
answer = flow.agent(
question="Tell me about Paris",
user="trustgraph",
history=history
)
detect_type(self, sample)
Gundua aina ya data ya sampuli ya data iliyohifadhiwa.
Vigezo:
sample: Sampuli ya data kuchanganua (yaliyomo katika maandishi)
Inarudisha: kamusi yenye aina_iliyogunduliwa, uaminifu, na metadata ya hiari
diagnose_data(self, sample, schema_name=None, options=None)
Fanya uchunguzi wa pamoja wa data: gundua aina na uundue maelezo.
Vigezo:
sample: Sampuli ya data kuchanganua (yaliyomo katika maandishi)
schema_name: Jina la schema ya lengo la hiari kwa uundaji wa maelezo
options: Vigezo vya hiari (k.m., kigawanyo kwa CSV)
Inarudisha: kamusi yenye aina_iliyogunduliwa, uaminifu, maelezo, na metadata
document_embeddings_query(self, text, user, collection, limit=10)
Tafuta vipande vya hati kwa kutumia utofauti wa maana.
Inapata vipande vya hati ambavyo yaliyomo katika vipande hivyo yanafanana kwa maana na maandishi ya ingizo, kwa kutumia uelekezo wa vector.
Vigezo:
text: Maandishi ya swali kwa utafutaji wa maana
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
limit: Nambari ya juu ya matokeo (ya kawaida: 10)
Inarudisha: kamusi: Matokeo ya swali yenye vipande vyenye kitambulisho cha kipande na alama
Mfano:
flow = api.flow().id("default")
results = flow.document_embeddings_query(
text="machine learning algorithms",
user="trustgraph",
collection="research-papers",
limit=5
)
# results contains {"chunks": [{"chunk_id": "doc1/p0/c0", "score": 0.95}, ...]}
document_rag(self, query, user='trustgraph', collection='default', doc_limit=10)
Tekeleza swali la Uzalishaji Ulioboreshwa na Utafiti (RAG) linalotegemea nyaraka.
RAG ya nyaraka hutumia ufashilia wa vector ili kupata vipande muhimu vya nyaraka, kisha huunda jibu kwa kutumia LLM (Large Language Model) kwa kutumia vipande hivyo kama muktadha.
Vigezo:
query: Swali katika lugha ya asili
user: Kitambulisho cha mtumiaji/nafasi (cha kawaida: "trustgraph")
collection: Kitambulisho cha mkusanyiko (cha kawaida: "default")
doc_limit: Vipande vingi vya nyaraka ambavyo vitapatikana (cha kawaida: 10)
Inarudisha: string: Jibu lililoundwa ambalo linajumuisha muktadha wa nyaraka
Mfano:
flow = api.flow().id("default")
response = flow.document_rag(
query="Summarize the key findings",
user="trustgraph",
collection="research-papers",
doc_limit=5
)
print(response)
embeddings(self, texts)
Toa ufafanuzi wa vector kwa maandishi moja au zaidi.
Hubadilisha maandishi kuwa uwakilishi wa vector mnono unaofaa kwa utafutaji wa maana na kulinganisha sawa.
Vigezo:
texts: Orodha ya maandishi ya pembeni ambayo yanahitajika kufafanuliwa
Inarudisha: list[list[list[float]]]: Ufafanuzi wa vector, seti moja kwa kila maandishi ya pembeni
Mfano:
flow = api.flow().id("default")
vectors = flow.embeddings(["quantum computing"])
print(f"Embedding dimension: {len(vectors[0][0])}")
generate_descriptor(self, sample, data_type, schema_name, options=None)
Tengeneza maelezo kwa ajili ya uhusiano wa data iliyopangwa na mpango maalum.
Vigezo:
sample: Sampuli ya data ya kuchambua (maudhui ya maandishi)
data_type: Aina ya data (csv, json, xml)
schema_name: Jina la mpango unaolengwa kwa ajili ya utengenezaji wa maelezo
options: Vigezo vya hiari (k.m., kigawanyo kwa CSV)
Inarudisha: kamusi yenye maelezo na metadata
graph_embeddings_query(self, text, user, collection, limit=10)
Tafuta vitu vya grafu ya maarifa kwa kutumia ufanano wa maana.
Inatafuta vitu katika grafu ya maarifa ambavyo maelezo yake yanafanana na maandishi yaingizwavyo, kwa kutumia uelekezo wa vector.
Vigezo:
text: Maandishi ya swali kwa ajili ya utafutaji wa maana
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
limit: Nambari ya juu ya matokeo (ya kawaida: 10)
Inarudisha: kamusi: Matokeo ya swali na vitu vinavyofanana
Mfano:
flow = api.flow().id("default")
results = flow.graph_embeddings_query(
text="physicist who discovered radioactivity",
user="trustgraph",
collection="scientists",
limit=5
)
# results contains {"entities": [{"entity": {...}, "score": 0.95}, ...]}
graph_rag(self, query, user='trustgraph', collection='default', entity_limit=50, triple_limit=30, max_subgraph_size=150, max_path_length=2)
Tekeleza swali la Uzalishaji Ulioboreshwa na Utafutaji (RAG) unaotegemea grafu.
RAG ya grafu hutumia muundo wa grafu ya maarifa ili kupata muktadha unaohusiana kwa kutumia uhusiano wa vitu, kisha huunda jibu kwa kutumia LLM.
Vigezo:
query: Swali la lugha ya asili
user: Kitambulisho cha mtumiaji/nafasi (cha kawaida: "trustgraph")
collection: Kitambulisho cha mkusanyiko (cha kawaida: "default")
entity_limit: Vitu vingi zaidi ya kuchuja (cha kawaida: 50)
triple_limit: Triples nyingi zaidi kwa kila kitu (cha kawaida: 30)
max_subgraph_size: Triples jumla nyingi zaidi katika subgraph (cha kawaida: 150)
max_path_length: Kina cha juu zaidi cha utafutaji (cha kawaida: 2)
Inarudisha: string: Jibu lililoundwa ambalo linajumuisha muktadha wa grafu
Mfano:
flow = api.flow().id("default")
response = flow.graph_rag(
query="Tell me about Marie Curie's discoveries",
user="trustgraph",
collection="scientists",
entity_limit=20,
max_path_length=3
)
print(response)
load_document(self, document, id=None, metadata=None, user=None, collection=None)
Pakia hati ya binary ili kuendelea na usindikaji.
Hupakia hati (PDF, DOCX, picha, n.k.) ili kuchukua maelezo na kuendelea na usindikaji kupitia mchakato wa hati.
Vigezo:
document: Yaliyomo katika hati kama bytes
id: Kitambulisho cha hati cha hiari (kinatengenezwa kiotomatiki ikiwa hakipo)
metadata: Meta-data ya hiari (orodha ya Triples au kitu na njia ya emit)
user: Kitambulisho cha mtumiaji/nafasi (cha hiari)
collection: Kitambulisho cha mkusanyiko (cha hiari)
Inarudisha: dict: Jibu la usindikaji
Inatirisha:
RuntimeError: Ikiwa meta-data imetolewa bila kitambulisho
Mfano:
flow = api.flow().id("default")
# Load a PDF document
with open("research.pdf", "rb") as f:
result = flow.load_document(
document=f.read(),
id="research-001",
user="trustgraph",
collection="papers"
)
load_text(self, text, id=None, metadata=None, charset='utf-8', user=None, collection=None)
Pakia maudhui ya maandishi kwa ajili ya uchakataji.
Hupakia maudhui ya maandishi kwa ajili ya uondoaji na uchakataji kupitia njia ya maandishi ya mtiririko.
Vigezo:
text: Maudhui ya maandishi kama bytes
id: Kitambulisho cha hati cha hiari (kinaundwa kiotomatiki ikiwa hakipo)
metadata: Meta data ya hiari (orodha ya Triples au kitu na njia ya emit)
charset: Ufuatiliaji wa herufi (kiasi: "utf-8")
user: Kitambulisho cha mtumiaji/nafasi (cha hiari)
collection: Kitambulisho cha mkusanyiko (cha hiari)
Inarudisha: dict: Jibu la uchakataji
Inayotokea:
RuntimeError: Ikiwa meta data imetolewa bila kitambulisho
Mfano:
flow = api.flow().id("default")
# Load text content
text_content = b"This is the document content..."
result = flow.load_text(
text=text_content,
id="text-001",
charset="utf-8",
user="trustgraph",
collection="documents"
)
mcp_tool(self, name, parameters={})
Fanya kazi na zana ya Itifaki ya Mfumo (MCP).
Zana za MCP hutoa utendakazi unaoweza kupanuliwa kwa wakala na michakato, kuruhusu ujumuishaji na mifumo na huduma za nje.
Vigezo:
name: Jina/kitambulisho cha zana
parameters: Kamusi ya vigezo vya zana (ya kawaida: {})
Inarudisha: string au kamusi: Matokeo ya utekelezaji wa zana
Inatirisha:
ProtocolException: Ikiwa muundo wa majibu hauna uhakika
Mfano:
flow = api.flow().id("default")
# Execute a tool
result = flow.mcp_tool(
name="search-web",
parameters={"query": "latest AI news", "limit": 5}
)
nlp_query(self, question, max_results=100)
Badilisha swali la lugha ya asili kuwa ombi la GraphQL.
Vigezo:
question: Swali la lugha ya asili
max_results: Nambari ya juu ya matokeo yanayorudishwa (ya kawaida: 100)
Inarudisha: kamusi yenye graphql_query, variables, detected_schemas, uaminifu
prompt(self, id, variables)
Tekeleza kiolezo cha ombi kwa kubadilisha vigezo.
Kiolezo cha ombi huruhusu muundo wa ombi unaoweza kutumika tena na kubadilisha vigezo, muhimu kwa uhandisi wa ombi unaoendana.
Vigezo:
id: Kitambulisho cha kiolezo cha ombi
variables: Kamusi ya ulinganisho wa jina la kigezo hadi thamani
Inarudisha: string au kamusi: Matokeo ya ombi yaliyobadilishwa (maandishi au kitu kilicho na muundo)
Inatirisha:
ProtocolException: Ikiwa muundo wa jibu sio sahihi
Mfano:
flow = api.flow().id("default")
# Text template
result = flow.prompt(
id="summarize-template",
variables={"topic": "quantum computing", "length": "brief"}
)
# Structured template
result = flow.prompt(
id="extract-entities",
variables={"text": "Marie Curie won Nobel Prizes"}
)
request(self, path, request)
Toa ombi la huduma katika toleo hili la mtiririko.
Vigezo:
path: Njia ya huduma (k.m., "service/text-completion")
request: Kamusi ya data ya ombi
Inarudisha: dict: Jibu la huduma
row_embeddings_query(self, text, schema_name, user='trustgraph', collection='default', index_name=None, limit=10)
Tafuta data ya mstari kwa kutumia ufanano wa maana kwenye sehemu zilizofichwa.
Inatafuta mistari ambayo maadili ya sehemu zilizofichwa yanafanana kwa maana na maandishi ya ingizo, kwa kutumia uelekezo wa vector. Hii inaruhusu utafutaji wa "fuzzy"/maana kwenye data iliyopangwa.
Vigezo:
text: Maandishi ya swali kwa utafutaji wa maana
schema_name: Jina la mpango wa kutafuta ndani
user: Kitambulisho cha mtumiaji/nafasi (cha kawaida: "trustgraph")
collection: Kitambulisho cha mkusanyiko (cha kawaida: "default")
index_name: Jina la fahirisi la hiari ili kuchuja utafutaji kwa fahirisi maalum
limit: Idadi ya juu ya matokeo (cha kawaida: 10)
Inarudisha: dict: Matokeo ya utafutaji ambayo yana mechi, na yana index_name, index_value, text, na score
Mfano:
flow = api.flow().id("default")
# Search for customers by name similarity
results = flow.row_embeddings_query(
text="John Smith",
schema_name="customers",
user="trustgraph",
collection="sales",
limit=5
)
# Filter to specific index
results = flow.row_embeddings_query(
text="machine learning engineer",
schema_name="employees",
index_name="job_title",
limit=10
)
rows_query(self, query, user='trustgraph', collection='default', variables=None, operation_name=None)
Tekeleza swali la GraphQL dhidi ya safu zilizopangwa katika grafu ya maarifa.
Maswali hutumia data iliyopangwa kwa lugha ya GraphQL, na kuruhusu maswali magumu yenye kuchujwa, ukusanyaji, na uhusiano.
Vigezo:
query: Mnyororo wa swali la GraphQL
user: Kitambulisho cha mtumiaji/nafasi (cha kawaida: "trustgraph")
collection: Kitambulisho cha mkusanyiko (cha kawaida: "default")
variables: Kamusi ya vigezo vya swali ya hiari
operation_name: Jina la operesheni ya hiari kwa hati za operesheni nyingi
Inarudisha: dict: Jibu la GraphQL na sehemu za 'data', 'errors', na/au 'extensions'
Inatirisha:
ProtocolException: Ikiwa hitilafu ya kiwango cha mfumo hutokea
Mfano:
flow = api.flow().id("default")
# Simple query
query = '''
{
scientists(limit: 10) {
name
field
discoveries
}
}
'''
result = flow.rows_query(
query=query,
user="trustgraph",
collection="scientists"
)
# Query with variables
query = '''
query GetScientist($name: String!) {
scientists(name: $name) {
name
nobelPrizes
}
}
'''
result = flow.rows_query(
query=query,
variables={"name": "Marie Curie"}
)
schema_selection(self, sample, options=None)
Chagua schemas zinazolingana kwa sampuli ya data kwa kutumia uchambuzi wa swali.
Vigezo:
sample: Sampuli ya data ya kuchambua (maudhui ya maandishi)
options: Vigezo vya hiari
Inarudisha: kamusi yenye safu ya schema_matches na metadata
structured_query(self, question, user='trustgraph', collection='default')
Tekeleza swali la lugha ya asili dhidi ya data iliyopangwa. Inachanganya ubadilishaji wa swali la NLP na utekelezaji wa GraphQL.
Vigezo:
question: Swali la lugha ya asili
user: Kitambulisho cha nafasi ya Cassandra (cha kawaida: "trustgraph")
collection: Kitambulisho cha mkusanyiko wa data (cha kawaida: "default")
Inarudisha: kamusi yenye data na makosa yanayohitajika
text_completion(self, system, prompt)
Tekeleza kukamilisha maandishi kwa kutumia LLM ya mtiririko.
Vigezo:
system: Swali la mfumo linalobainisha tabia ya msaidizi
prompt: Swali/swali la mtumiaji
Inarudisha: maandishi: Jibu lililoundwa
Mfano:
flow = api.flow().id("default")
response = flow.text_completion(
system="You are a helpful assistant",
prompt="What is quantum computing?"
)
print(response)
triples_query(self, s=None, p=None, o=None, user=None, collection=None, limit=10000)
Tafuta ujuzi wa grapu kwa kutumia utangamano.
Inatafuta triplet za RDF zinazofanana na mada, tabia, na/au mifumo ya kitu. Vigezo visivyotajwa hufanya kama vichwa vya habari.
Vigezo:
s: URI ya mada (hiari, tumia None kwa kichwa cha habari)
p: URI ya tabia (hiari, tumia None kwa kichwa cha habari)
o: URI ya kitu au Literal (hiari, tumia None kwa kichwa cha habari)
user: Kitambulisho cha mtumiaji/nafasi (hiari)
collection: Kitambulisho cha mkusanyiko (hiari)
limit: Matokeo ya juu ya kurejesha (ya kawaida: 10000)
Inarejea: list[Triple]: Orodha ya vitu vinavyolingana vya Triple
Inatiruka:
RuntimeError: Ikiwa s au p si Uri, au o si Uri/Literal
Mfano:
from trustgraph.knowledge import Uri, Literal
flow = api.flow().id("default")
# Find all triples about a specific subject
triples = flow.triples_query(
s=Uri("http://example.org/person/marie-curie"),
user="trustgraph",
collection="scientists"
)
# Find all instances of a specific relationship
triples = flow.triples_query(
p=Uri("http://example.org/ontology/discovered"),
limit=100
)
--
AsyncFlow
from trustgraph.api import AsyncFlow
Mteja wa usimamizi wa mtiririko usio na usawisi, unaotumia API ya REST.
Hutoa operesheni za usimamizi wa mtiririko kulingana na async/await, ikiwa ni pamoja na kuorodhesha, kuanzisha, kusimamisha mitiririko, na kusimamia ufafanuzi wa darasa la mtiririko. Pia hutoa ufikiaji wa huduma za mtiririko kama vile wakala, RAG, na maswali kupitia sehemu za mwisho za REST ambazo hazitumii utiririshaji.
Kumbuka: Kwa usaidizi wa utiririshaji, tumia AsyncSocketClient badala yake.
Mbinu
__init__(self, url: str, timeout: int, token: str | None) -> None
Anzisha mteja wa mtiririko usio na usawisi.
Majadiliano:
url: URL ya msingi ya API ya TrustGraph
timeout: Muda wa kuchelewa wa ombi kwa sekunde
token: Tokeni ya kuhifadhiwa ya hiari kwa uthibitishaji
aclose(self) -> None
Funga mteja usio na usawisi na safisha rasilimali.
Kumbuka: Usafishaji unashughulikiwa kiotomatiki na meneja wa muktadha wa kikao cha aiohttp. Mbinu hii hutolewa kwa utangamano na wateja wengine wasio na usawisi.
delete_class(self, class_name: str)
Futa ufafanuzi wa darasa la mtiririko.
Huondoa mpango wa darasa la mtiririko kutoka kwenye mfumo. Haathiri mifano ya mtiririko inayoruka.
Majadiliano:
class_name: Jina la darasa la mtiririko kufutwa
Mfano:
async_flow = await api.async_flow()
# Delete a flow class
await async_flow.delete_class("old-flow-class")
get(self, id: str) -> Dict[str, Any]
Pata ufafanuzi wa mtiririko.
Hupata usanidi kamili wa mtiririko, pamoja na jina lake la darasa, maelezo, na vigezo.
Vigezo:
id: Kitambulisho cha mtiririko
Inarudisha: dict: Kitu cha ufafanuzi wa mtiririko
Mfano:
async_flow = await api.async_flow()
# Get flow definition
flow_def = await async_flow.get("default")
print(f"Flow class: {flow_def.get('class-name')}")
print(f"Description: {flow_def.get('description')}")
get_class(self, class_name: str) -> Dict[str, Any]
Pata ufafanuzi wa darasa la mtiririko.
Inapata ufafanuzi wa mpango wa darasa la mtiririko, pamoja na mpango wake wa usanidi na viunganisho vya huduma.
Vigezo:
class_name: Jina la darasa la mtiririko
Inarudisha: dict: Kitu kinachowakilisha ufafanuzi wa darasa la mtiririko
Mfano:
async_flow = await api.async_flow()
# Get flow class definition
class_def = await async_flow.get_class("default")
print(f"Services: {class_def.get('services')}")
id(self, flow_id: str)
Pata mteja wa mtiririko wa async.
Inarudisha mteja kwa ajili ya kuingiliana na huduma za mtiririko maalum (wakala, RAG, maswali, ufumbuzi, n.k.).
Majadiliano:
flow_id: Kitambulisho cha mtiririko
Inarudisha: AsyncFlowInstance: Mteja kwa operesheni maalum za mtiririko
Mfano:
async_flow = await api.async_flow()
# Get flow instance
flow = async_flow.id("default")
# Use flow services
result = await flow.graph_rag(
query="What is TrustGraph?",
user="trustgraph",
collection="default"
)
list(self) -> List[str]
Orodha ya kitambulisho cha kila mtiririko.
Inapata kitambulisho cha kila mtiririko unaoendeshwa kwa sasa katika mfumo.
Inarudisha: list[str]: Orodha ya kitambulisho cha mtiririko
Mfano:
async_flow = await api.async_flow()
# List all flows
flows = await async_flow.list()
print(f"Available flows: {flows}")
list_classes(self) -> List[str]
Orodha ya majina yote ya darasa la mtiririko.
Inapata majina ya madarasa yote ya mtiririko (mipango) yanayopatikana katika mfumo.
Inarudisha: list[str]: Orodha ya majina ya darasa la mtiririko.
Mfano:
async_flow = await api.async_flow()
# List available flow classes
classes = await async_flow.list_classes()
print(f"Available flow classes: {classes}")
put_class(self, class_name: str, definition: Dict[str, Any])
Kuunda au kusasisha ufafanuzi wa darasa la mtiririko.
Hifadhi mfumo wa darasa la mtiririko ambao unaweza kutumika kuunda mitiririko.
Vigezo:
class_name: Jina la darasa la mtiririko
definition: Kifaa cha ufafanuzi cha darasa la mtiririko
Mfano:
async_flow = await api.async_flow()
# Create a custom flow class
class_def = {
"services": {
"agent": {"module": "agent", "config": {...}},
"graph-rag": {"module": "graph-rag", "config": {...}}
}
}
await async_flow.put_class("custom-flow", class_def)
request(self, path: str, request_data: Dict[str, Any]) -> Dict[str, Any]
Fanya ombi la HTTP POST lisilo na usumbufu kwa API ya Gateway.
Njia ya ndani ya kutuma ombi lililo na uthibitisho kwa API ya TrustGraph.
Vigezo:
path: Njia ya mwisho ya API (kulinganisha na URL ya msingi)
request_data: Kamusi ya data inayotumwa kwenye ombi
Inarudisha: dict: Kielelezo cha majibu kutoka kwa API
Inayotokea:
ProtocolException: Ikiwa hali ya HTTP si 200 au majibu hayana umbizo sahihi la JSON
ApplicationException: Ikiwa API inarudisha jibu la kosa
start(self, class_name: str, id: str, description: str, parameters: Dict | None = None)
Anzisha mfumo mpya wa utekelezaji.
Huunda na kuanzisha mfumo kutoka kwa ufafanuzi wa darasa la mfumo pamoja na vigezo vilivyoelezwa.
Vigezo:
class_name: Jina la darasa la mfumo linalotumiwa
id: Kitambulisho cha mfumo mpya
description: Maelezo yanayoweza kusomwa na binadamu ya mfumo
parameters: Vigezo vya ziada vya usanidi vya mfumo
Mfano:
async_flow = await api.async_flow()
# Start a flow from a class
await async_flow.start(
class_name="default",
id="my-flow",
description="Custom flow instance",
parameters={"model": "claude-3-opus"}
)
stop(self, id: str)
Kusimamisha mtiririko unaoendelea.
Inasimamisha na kuondoa mfano wa mtiririko, na kutoa rasilimali zake.
Vigezo:
id: Kitambulisho cha mtiririko ili kusimamishwa
Mfano:
async_flow = await api.async_flow()
# Stop a flow
await async_flow.stop("my-flow")
--
AsyncFlowInstance
from trustgraph.api import AsyncFlowInstance
Mteja wa mfumo wa kazi usiofanyika kwa wakati mmoja.
Hutoa ufikiaji wa async/await kwa huduma za mfumo wa kazi, ikiwa ni pamoja na wakala, Maswali ya RAG, maandamano, na maswali ya grafu. Operesheni zote hurudisha majibu kamili (ya moja kwa moja).
Kumbuka: Kwa usaidizi wa utiririshaji, tumia AsyncSocketFlowInstance.
Mbinu
__init__(self, flow: trustgraph.api.async_flow.AsyncFlow, flow_id: str)
Anzisha mfumo wa kazi usiofanyika kwa wakati mmoja.
Majadiliano:
flow: Mteja wa AsyncFlow mkuu
flow_id: Kitambulisho cha mfumo wa kazi
agent(self, question: str, user: str, state: Dict | None = None, group: str | None = None, history: List | None = None, **kwargs: Any) -> Dict[str, Any]
Fanya operesheni ya wakala (ya moja kwa moja).
Huendesha wakala kujibu swali, pamoja na hali ya mazungumzo na historia. Inarudisha jibu kamili baada ya wakala kumaliza kuchakata.
Kumbuka: Njia hii haitumii utiririshaji. Kwa mawazo na matokeo ya wakala ya wakati halisi, tumia AsyncSocketFlowInstance.agent() badala yake.
Majadiliano:
question: Suali au maagizo ya mtumiaji
user: Kitambulisho cha mtumiaji
state: Kamusi ya hali ya hiari kwa muktadha wa mazungumzo
group: Kitambulisho cha kikundi cha hiari kwa usimamizi wa kikao
history: Orodha ya historia ya mazungumzo ya hiari
**kwargs: Vigezo vya ziada maalum kwa huduma
Inarudisha: dict: Jibu kamili la wakala ikiwa ni pamoja na jibu na metadata
Mfano:
async_flow = await api.async_flow()
flow = async_flow.id("default")
# Execute agent
result = await flow.agent(
question="What is the capital of France?",
user="trustgraph"
)
print(f"Answer: {result.get('response')}")
document_rag(self, query: str, user: str, collection: str, doc_limit: int = 10, **kwargs: Any) -> str
Fanya swali la RAG (Retrieval-Augmented Generation) linalotegemea hati (si mtiririko).
Hufanya Uundaji Ulioboreshwa kwa Upatanishaji kwa kutumia ufichuo wa hati. Hupata vipande muhimu vya hati kupitia utafutaji wa maana, kisha huunda jibu linalotegemea hati zilizopatikana. Inarudisha jibu kamili.
Kumbuka: Njia hii haitumii mtiririko. Kwa majibu ya RAG yanayotumia mtiririko, tumia AsyncSocketFlowInstance.document_rag() badala yake.
Vigezo:
query: Nakala ya swali la mtumiaji
user: Kitambulisho cha mtumiaji
collection: Kitambulisho cha mkusanyiko unao na hati
doc_limit: Nambari ya juu ya vipande vya hati ambavyo vinaweza kupatikana (kiwango chachilia: 10)
**kwargs: Vigezo vya ziada vinavyohusiana na huduma
Inarudisha: str: Jibu kamili lililoundwa na linalotegemea data ya hati
Mfano:
async_flow = await api.async_flow()
flow = async_flow.id("default")
# Query documents
response = await flow.document_rag(
query="What does the documentation say about authentication?",
user="trustgraph",
collection="docs",
doc_limit=5
)
print(response)
embeddings(self, texts: list, **kwargs: Any)
Toa maelezo kwa maandishi ya pembejeo.
Hubadilisha maandishi kuwa uwakilishi wa nambari za vector kwa kutumia mfumo wa embedding uliopangwa wa mtiririko. Ni muhimu kwa utafutaji wa maana na ulinganisho wa alama.
Vigezo:
texts: Orodha ya maandishi ya pembejeo ambayo yanahitajika kuwekwa maelezo.
**kwargs: Vigezo vya ziada maalum kwa huduma.
Inarudisha: dict: Jibu lenye vector za maelezo.
Mfano:
async_flow = await api.async_flow()
flow = async_flow.id("default")
# Generate embeddings
result = await flow.embeddings(texts=["Sample text to embed"])
vectors = result.get("vectors")
print(f"Embedding dimension: {len(vectors[0][0])}")
graph_embeddings_query(self, text: str, user: str, collection: str, limit: int = 10, **kwargs: Any)
Tafuta ujumuishi wa grafu kwa ajili ya utafutaji wa vitu vya maana.
Hufanya utafutaji wa maana kwenye ujumuishi wa vitu vya grafu ili kupata vitu ambavyo ni muhimu zaidi kwa maandishi yaliyopo. Inarudisha vitu vilivyopangwa kwa umuhimu.
Vigezo:
text: Maandishi ya swali kwa utafutaji wa maana
user: Kitambulisho cha mtumiaji
collection: Kitambulisho cha mkusanyiko unao na ujumuishi wa grafu
limit: Nambari ya juu ya matokeo yanayorudishwa (ya kawaida: 10)
**kwargs: Vigezo vya ziada maalum kwa huduma
Inarudisha: dict: Jibu linalo na vitu vinavyolingana vilivyopangwa pamoja na alama za umuhimu
Mfano:
async_flow = await api.async_flow()
flow = async_flow.id("default")
# Find related entities
results = await flow.graph_embeddings_query(
text="machine learning algorithms",
user="trustgraph",
collection="tech-kb",
limit=5
)
for entity in results.get("entities", []):
print(f"{entity['name']}: {entity['score']}")
graph_rag(self, query: str, user: str, collection: str, max_subgraph_size: int = 1000, max_subgraph_count: int = 5, max_entity_distance: int = 3, **kwargs: Any) -> str
Tekeleza swali la RAG linalotegemea grafu (lisilo na utiririshaji).
Hufanya Uundaji Ulioboreshwa na Upatanishaji kwa kutumia data ya grafu ya maarifa. Hutambua vitu muhimu na uhusiano wao, kisha huunda jibu ambalo limekithiri katika muundo wa grafu. Inarudisha jibu kamili.
Kumbuka: Njia hii haitumii utiririshaji. Kwa majibu ya RAG yanayotumia utiririshaji, tumia AsyncSocketFlowInstance.graph_rag() badala yake.
Vigezo:
query: Nakala ya swali la mtumiaji
user: Kitambulisho cha mtumiaji
collection: Kitambulisho cha mkusanyiko unao na grafu ya maarifa
max_subgraph_size: Nambari ya juu ya triplet kwa kila subgrafu (ya kawaida: 1000)
max_subgraph_count: Nambari ya juu ya subgrafu za kuchukuliwa (ya kawaida: 5)
max_entity_distance: Umbali wa juu wa grafu kwa upanuzi wa vitu (ya kawaida: 3)
**kwargs: Vigezo vya ziada vya huduma maalum
Inarudisha: string: Jibu kamili lililoundwa ambalo limekithiri katika data ya grafu
Mfano:
async_flow = await api.async_flow()
flow = async_flow.id("default")
# Query knowledge graph
response = await flow.graph_rag(
query="What are the relationships between these entities?",
user="trustgraph",
collection="medical-kb",
max_subgraph_count=3
)
print(response)
request(self, service: str, request_data: Dict[str, Any]) -> Dict[str, Any]
Tafadhali omba huduma iliyo ndani ya eneo la mtiririko.
Njia ya ndani ya kuita huduma ndani ya mfano huu wa mtiririko.
Vigezo:
service: Jina la huduma (k.m., "agent", "graph-rag", "triples")
request_data: Takwimu ya ombi la huduma
Inarudisha: dict: Kielelezo cha jibu la huduma
Inatirisha:
ProtocolException: Ikiwa ombi halikubaliwi au jibu ni batili
ApplicationException: Ikiwa huduma inarudisha kosa
row_embeddings_query(self, text: str, schema_name: str, user: str = 'trustgraph', collection: str = 'default', index_name: str | None = None, limit: int = 10, **kwargs: Any)
Tafuta ujumbe wa mistari ili kutafuta maana katika data iliyopangwa.
Hufanya utafutaji wa maana kwenye ujumbe wa mistari ili kupata mistari ambayo maadili ya sehemu iliyopangwa ni sawa zaidi na maandishi ya ingizo. Inaruhusu utangamano/ufanisi wa maana katika data iliyopangwa.
Vigezo:
text: Maandishi ya swali kwa utafutaji wa maana
schema_name: Jina la mpango wa kutafuta ndani
user: Kitambulisho cha mtumiaji (kawaida: "trustgraph")
collection: Kitambulisho cha mkusanyiko (kawaida: "default")
index_name: Jina la faharasa la hiari ili kuchuja utafutaji kwa faharasa maalum
limit: Nambari ya juu ya matokeo ya kurejesha (kawaida: 10)
**kwargs: Vigezo vya ziada vya huduma
Inarudisha: dict: Jibu linalo na mechi pamoja na index_name, index_value, text, na score
Mfano:
async_flow = await api.async_flow()
flow = async_flow.id("default")
# Search for customers by name similarity
results = await flow.row_embeddings_query(
text="John Smith",
schema_name="customers",
user="trustgraph",
collection="sales",
limit=5
)
for match in results.get("matches", []):
print(f"{match['index_name']}: {match['index_value']} (score: {match['score']})")
rows_query(self, query: str, user: str, collection: str, variables: Dict | None = None, operation_name: str | None = None, **kwargs: Any)
Tekeleza swali la GraphQL kwenye mistari iliyohifadhiwa.
Maswali hutumia mistari iliyo na muundo kwa kutumia sintaksia ya GraphQL. Inasaidia maswali magumu yenye vigezo na operesheni zilizo na majina.
Vigezo:
query: Mnyororo wa swali la GraphQL
user: Kitambulisho cha mtumiaji
collection: Kitambulisho cha mkusanyiko unao na mistari
variables: Vigezo vya swali la GraphQL vya hiari
operation_name: Jina la operesheni la hiari kwa maswali mengi
**kwargs: Vigezo vya ziada vya mahitaji ya huduma
Inarudisha: dict: Jibu la GraphQL lenye data na/au makosa
Mfano:
async_flow = await api.async_flow()
flow = async_flow.id("default")
# Execute GraphQL query
query = '''
query GetUsers($status: String!) {
users(status: $status) {
id
name
email
}
}
'''
result = await flow.rows_query(
query=query,
user="trustgraph",
collection="users",
variables={"status": "active"}
)
for user in result.get("data", {}).get("users", []):
print(f"{user['name']}: {user['email']}")
text_completion(self, system: str, prompt: str, **kwargs: Any) -> str
Toa maandishi yaliyokamilika (hayajazalishwa kwa utiririshaji).
Huunda jibu la maandishi kutoka kwa mfumo wa LLM (Large Language Model) kwa kutumia maagizo ya mfumo na maagizo ya mtumiaji. Inarudisha maandishi kamili ya jibu.
Kumbuka: Njia hii haitumii utiririshaji. Kwa utiririshaji wa maandishi, tumia AsyncSocketFlowInstance.text_completion() badala yake.
Vigezo:
system: Maagizo ya mfumo ambayo yanaeleza tabia ya mfumo wa LLM.
prompt: Maagizo ya mtumiaji au swali.
**kwargs: Vigezo vya ziada ambavyo ni mahususi kwa huduma.
Inarudisha: str: Jibu kamili la maandishi lililozalishwa.
Mfano:
async_flow = await api.async_flow()
flow = async_flow.id("default")
# Generate text
response = await flow.text_completion(
system="You are a helpful assistant.",
prompt="Explain quantum computing in simple terms."
)
print(response)
triples_query(self, s=None, p=None, o=None, user=None, collection=None, limit=100, **kwargs: Any)
Tafuta maneno matatu ya RDF kwa kutumia utambuzi wa muundo.
Inatafuta maneno matatu yanayolingana na mada, sifa, na/au mifumo ya kitu. Mifumo hutumia "Hakuna" kama ishara ya kujielekeza ili kuangalia thamani yoyote.
Vigezo:
s: Mfumo wa mada (Hakuna kwa kujielekeza)
p: Mfumo wa sifa (Hakuna kwa kujielekeza)
o: Mfumo wa kitu (Hakuna kwa kujielekeza)
user: Kitambulisho cha mtumiaji (Hakuna kwa watumiaji wote)
collection: Kitambulisho cha mkusanyiko (Hakuna kwa mkusanyiko wote)
limit: Nambari ya juu ya maneno matatu ya kurejesha (ya kawaida: 100)
**kwargs: Vigezo vya ziada maalum kwa huduma
Inarejea: dict: Jibu lenye maneno matatu yanayolingana
Mfano:
async_flow = await api.async_flow()
flow = async_flow.id("default")
# Find all triples with a specific predicate
results = await flow.triples_query(
p="knows",
user="trustgraph",
collection="social",
limit=50
)
for triple in results.get("triples", []):
print(f"{triple['s']} knows {triple['o']}")
--
SocketClient
from trustgraph.api import SocketClient
Mteja wa WebSocket wa wakati mmoja kwa operesheni za utiririshaji.
Hutoa kiolesura cha wakati mmoja kwa huduma za TrustGraph zinazotegemea WebSocket, ikibadilisha maktabu ya websockets ya asinkroni na jenereta za wakati mmoja ili iwe rahisi kutumia. Inasaidia majibu ya utiririshaji kutoka kwa wakala, maswali ya RAG, na kukamilisha maandishi.
Kumbuka: Hii ni kifungashio cha wakati mmoja kilichoanzishwa kwenye operesheni za WebSocket za asinkroni. Kwa usaidizi wa kweli wa asinkroni, tumia AsyncSocketClient badala yake.
Mbinu
__init__(self, url: str, timeout: int, token: str | None) -> None
Anzisha mteja wa WebSocket wa wakati mmoja.
Majadiliano:
url: URL ya msingi kwa API ya TrustGraph (HTTP/HTTPS itabadilishwa kuwa WS/WSS)
timeout: Muda wa kimya wa WebSocket kwa sekunde
token: Tokeni ya kuhifadhia ya hiari kwa uthibitishaji
close(self) -> None
Funga miunganisho ya WebSocket.
Kumbuka: Usafi unashughulikiwa kiotomatiki na wasimamizi wa muktadha katika msimbo wa asinkroni.
flow(self, flow_id: str) -> 'SocketFlowInstance'
Pata mfano wa mtiririko kwa operesheni za utiririshaji wa WebSocket.
Majadiliano:
flow_id: Kitambulisho cha mtiririko
Inarudisha: SocketFlowInstance: Mfano wa mtiririko na mbinu za utiririshaji
Mfano:
socket = api.socket()
flow = socket.flow("default")
# Stream agent responses
for chunk in flow.agent(question="Hello", user="trustgraph", streaming=True):
print(chunk.content, end='', flush=True)
--
SocketFlowInstance
from trustgraph.api import SocketFlowInstance
Mfumo wa mawasiliano ya WebSocket wa wakati mmoja kwa operesheni za utiririshaji.
Hutoa kiolesura sawa na FlowInstance ya REST lakini na msaada wa utiririshaji wa WebSocket
kwa majibu ya wakati halisi. Mbinu zote zinaunga mkono parameter ya hiari
streaming ili kuwezesha utoaji wa matokeo kwa hatua.
Mbinu
__init__(self, client: trustgraph.api.socket_client.SocketClient, flow_id: str) -> None
Anzisha mfumo wa utiririshaji wa soketi.
Majadiliano:
client: Soketi ya Msimamizi
flow_id: Kitambulisho cha mtiririko
agent(self, question: str, user: str, state: Dict[str, Any] | None = None, group: str | None = None, history: List[Dict[str, Any]] | None = None, streaming: bool = False, **kwargs: Any) -> Dict[str, Any] | Iterator[trustgraph.api.types.StreamingChunk]
Fanya operesheni ya wakala na msaada wa utiririshaji.
Wakala wanaweza kufanya utaratibu wa hatua kadhaa kwa kutumia zana. Mbinu hii daima hurudisha vipande vya utiririshaji (mawazo, uchunguzi, majibu) hata wakati streaming=False, ili kuonyesha mchakato wa utafakari wa wakala.
Majadiliano:
question: Swali au maagizo ya mtumiaji
user: Kitambulisho cha mtumiaji
state: Kamusi ya hiari ya hali kwa mazungumzo ya hali
group: Kitambulisho cha hiari cha kikundi kwa muktadha wa watumiaji wengi
history: Historia ya hiari ya mazungumzo kama orodha ya maneno
streaming: Washa hali ya utiririshaji (kiasi: False)
**kwargs: Vigezo vya ziada vilivyopitishwa kwa huduma ya wakala
Hurejesha: Iterator[StreamingChunk]: Mto wa mawazo, uchunguzi, na majibu ya wakala
Mfano:
socket = api.socket()
flow = socket.flow("default")
# Stream agent reasoning
for chunk in flow.agent(
question="What is quantum computing?",
user="trustgraph",
streaming=True
):
if isinstance(chunk, AgentThought):
print(f"[Thinking] {chunk.content}")
elif isinstance(chunk, AgentObservation):
print(f"[Observation] {chunk.content}")
elif isinstance(chunk, AgentAnswer):
print(f"[Answer] {chunk.content}")
agent_explain(self, question: str, user: str, collection: str, state: Dict[str, Any] | None = None, group: str | None = None, history: List[Dict[str, Any]] | None = None, **kwargs: Any) -> Iterator[trustgraph.api.types.StreamingChunk | trustgraph.api.types.ProvenanceEvent]
Fanya operesheni ya wakala pamoja na ufuatiliaji wa uelewaji.
Hutuma vipande vya maudhui (AgentThought, AgentObservation, AgentAnswer) na matukio ya asili (ProvenanceEvent). Matukio ya asili yana anwani za mtandao (URIs) ambazo zinaweza kupatikana kwa kutumia ExplainabilityClient ili kupata maelezo kuhusu mchakato wa utafakari wa wakala.
Ufuatiliaji wa wakala una vipengele vifuatavyo: Kipindi: Swali la awali na metadata ya kipindi Mzunguko: Kila mzunguko wa mawazo/tendo/uchunguzi Hitimisho: Jibu la mwisho
Vigezo:
question: Swali au maagizo ya mtumiaji
user: Kitambulisho cha mtumiaji
collection: Kitambulisho cha mkusanyiko kwa uhifadhi wa asili
state: Kamusi ya hali inayobadilika (optional) kwa mazungumzo yanayoendelea
group: Kitambulisho cha kikundi (optional) kwa mazingira ya watumiaji wengi
history: Historia ya mazungumzo (optional) kama orodha ya maneno
**kwargs: Vigezo vya ziada ambavyo hutumwa kwa huduma ya wakala
Yields:
Union[StreamingChunk, ProvenanceEvent]: Vipande vya wakala na matukio ya asili
Mfano:
from trustgraph.api import Api, ExplainabilityClient, ProvenanceEvent
from trustgraph.api import AgentThought, AgentObservation, AgentAnswer
socket = api.socket()
flow = socket.flow("default")
explain_client = ExplainabilityClient(flow)
provenance_ids = []
for item in flow.agent_explain(
question="What is the capital of France?",
user="trustgraph",
collection="default"
):
if isinstance(item, AgentThought):
print(f"[Thought] {item.content}")
elif isinstance(item, AgentObservation):
print(f"[Observation] {item.content}")
elif isinstance(item, AgentAnswer):
print(f"[Answer] {item.content}")
elif isinstance(item, ProvenanceEvent):
provenance_ids.append(item.explain_id)
# Fetch session trace after completion
if provenance_ids:
trace = explain_client.fetch_agent_trace(
provenance_ids[0], # Session URI is first
graph="urn:graph:retrieval",
user="trustgraph",
collection="default"
)
document_embeddings_query(self, text: str, user: str, collection: str, limit: int = 10, **kwargs: Any) -> Dict[str, Any]
Tafuta vipande vya hati kwa kutumia utambulisho wa maana.
Vigezo:
text: Nakala ya swali kwa utafutaji wa maana
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
limit: Nambari ya juu ya matokeo (ya kawaida: 10)
**kwargs: Vigezo vya ziada vilivyopitishwa kwa huduma
Inarudisha: dict: Matokeo ya swali na kitambulisho cha vipande vya hati vinavyolingana
Mfano:
socket = api.socket()
flow = socket.flow("default")
results = flow.document_embeddings_query(
text="machine learning algorithms",
user="trustgraph",
collection="research-papers",
limit=5
)
# results contains {"chunks": [{"chunk_id": "...", "score": 0.95}, ...]}
document_rag(self, query: str, user: str, collection: str, doc_limit: int = 10, streaming: bool = False, **kwargs: Any) -> str | Iterator[str]
Fanya swali la RAG (Retrieval-Augmented Generation) linalotegemea hati, na uwezekano wa kutumia utiririshaji.
Hutumia ufashiliaji wa vector ili kupata vipande muhimu vya hati, kisha huunda jibu kwa kutumia LLM (Large Language Model). Njia ya utiririshaji huwasilisha matokeo hatua kwa hatua.
Vigezo:
query: Swali la lugha ya asili
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
doc_limit: Idadi ya juu ya vipande vya hati ambavyo vinaweza kupatikana (kiwango chachilia: 10)
streaming: Washa hali ya utiririshaji (kiwango chachilia: False)
**kwargs: Vigezo vya ziada ambavyo hutumwa kwa huduma
Hurejesha: Union[str, Iterator[str]]: Jibu kamili au mkondo wa vipande vya maandishi
Mfano:
socket = api.socket()
flow = socket.flow("default")
# Streaming document RAG
for chunk in flow.document_rag(
query="Summarize the key findings",
user="trustgraph",
collection="research-papers",
doc_limit=5,
streaming=True
):
print(chunk, end='', flush=True)
document_rag_explain(self, query: str, user: str, collection: str, doc_limit: int = 10, **kwargs: Any) -> Iterator[trustgraph.api.types.RAGChunk | trustgraph.api.types.ProvenanceEvent]
Fanya swali la RAG (Retrieval-Augmented Generation) linalotegemea hati na linalo na uwezo wa kueleza.
Hutuma vipande vya maudhui (RAGChunk) na matukio ya asili (ProvenanceEvent). Matukio ya asili yana anwani za mtandao (URIs) ambazo zinaweza kupatikana kwa kutumia ExplainabilityClient ili kupata maelezo ya kina kuhusu jinsi jibu lilivyoundwa.
Mfuatiliaji wa RAG wa hati una vipengele vifuatavyo: Swali: Swali la mtumiaji Uchunguzi: Vipande vilivyopatikana kutoka kwenye hifadhi ya hati (idadi ya vipande) Muundo: Jibu lililoundwa
Vigezo:
query: Swali kwa lugha ya asili
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
doc_limit: Vipande vingi vya hati ambavyo vinaweza kupatikana (kiwango chachilia: 10)
**kwargs: Vigezo vya ziada ambavyo vinatumiwa kwa huduma
Yields:
Union[RAGChunk, ProvenanceEvent]: Vipande vya maudhui na matukio ya asili
Mfano:
from trustgraph.api import Api, ExplainabilityClient, RAGChunk, ProvenanceEvent
socket = api.socket()
flow = socket.flow("default")
explain_client = ExplainabilityClient(flow)
for item in flow.document_rag_explain(
query="Summarize the key findings",
user="trustgraph",
collection="research-papers",
doc_limit=5
):
if isinstance(item, RAGChunk):
print(item.content, end='', flush=True)
elif isinstance(item, ProvenanceEvent):
# Fetch entity details
entity = explain_client.fetch_entity(
item.explain_id,
graph=item.explain_graph,
user="trustgraph",
collection="research-papers"
)
print(f"Event: {entity}", file=sys.stderr)
embeddings(self, texts: list, **kwargs: Any) -> Dict[str, Any]
Toa ufafanuzi wa maandishi kwa ajili ya maandishi moja au zaidi.
Vigezo:
texts: Orodha ya maandishi ya pembeni ambayo yatatumika kuunda ufafanuzi.
**kwargs: Vigezo vya ziada ambavyo hutumwa kwa huduma.
Inarudisha: dict: Jibu ambalo lina ufafanuzi (kundi moja kwa kila maandishi ya pembeni).
Mfano:
socket = api.socket()
flow = socket.flow("default")
result = flow.embeddings(["quantum computing"])
vectors = result.get("vectors", [])
graph_embeddings_query(self, text: str, user: str, collection: str, limit: int = 10, **kwargs: Any) -> Dict[str, Any]
Tafuta vitu vya grafu ya maarifa kwa kutumia utambulisho wa maana.
Vigezo:
text: Nakala ya swali kwa utafutaji wa maana
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
limit: Nambari ya juu ya matokeo (ya kawaida: 10)
**kwargs: Vigezo vya ziada vilivyopitishwa kwa huduma
Inarudisha: dict: Matokeo ya swali na vitu vinavyofanana
Mfano:
socket = api.socket()
flow = socket.flow("default")
results = flow.graph_embeddings_query(
text="physicist who discovered radioactivity",
user="trustgraph",
collection="scientists",
limit=5
)
graph_rag(self, query: str, user: str, collection: str, max_subgraph_size: int = 1000, max_subgraph_count: int = 5, max_entity_distance: int = 3, streaming: bool = False, **kwargs: Any) -> str | Iterator[str]
Tekeleza swali la RAG linalotegemea grafu pamoja na utiririshaji wa hiari.
Hutumia muundo wa grafu ya maarifa ili kupata muktadha unaohusika, kisha huunda jibu kwa kutumia LLM. Njia ya utiririshaji huwasilisha matokeo hatua kwa hatua.
Vigezo:
query: Swali la lugha ya asili
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
max_subgraph_size: Idadi ya juu ya triplet katika subgrafu (ya kawaida: 1000)
max_subgraph_count: Idadi ya juu ya subgrafu (ya kawaida: 5)
max_entity_distance: Kina cha juu cha utafutaji (ya kawaida: 3)
streaming: Washa hali ya utiririshaji (ya kawaida: False)
**kwargs: Vigezo vya ziada ambavyo hutumwa kwa huduma
Hurejesha: Union[str, Iterator[str]]: Jibu kamili au mkondo wa vipande vya maandishi
Mfano:
socket = api.socket()
flow = socket.flow("default")
# Streaming graph RAG
for chunk in flow.graph_rag(
query="Tell me about Marie Curie",
user="trustgraph",
collection="scientists",
streaming=True
):
print(chunk, end='', flush=True)
graph_rag_explain(self, query: str, user: str, collection: str, max_subgraph_size: int = 1000, max_subgraph_count: int = 5, max_entity_distance: int = 3, **kwargs: Any) -> Iterator[trustgraph.api.types.RAGChunk | trustgraph.api.types.ProvenanceEvent]
Tekeleza swali la RAG linalotegemea grafu pamoja na utumiaji wa uelewaji.
Hutiririsha vipande vya maudhui (RAGChunk) na matukio ya asili (ProvenanceEvent). Matukio ya asili yana URI ambazo zinaweza kupatikana kwa kutumia ExplainabilityClient ili kupata maelezo ya kina kuhusu jinsi jibu lilivyoundwa.
Vigezo:
query: Swali la lugha ya asili
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
max_subgraph_size: Idadi ya juu ya triplet katika subgrafu (ya kawaida: 1000)
max_subgraph_count: Idadi ya juu ya subgrafu (ya kawaida: 5)
max_entity_distance: Kina cha juu cha utafutaji (ya kawaida: 3)
**kwargs: Vigezo vya ziada ambavyo hutumwa kwa huduma
Yields:
Union[RAGChunk, ProvenanceEvent]: Vipande vya maudhui na matukio ya asili
Mfano:
from trustgraph.api import Api, ExplainabilityClient, RAGChunk, ProvenanceEvent
socket = api.socket()
flow = socket.flow("default")
explain_client = ExplainabilityClient(flow)
provenance_ids = []
response_text = ""
for item in flow.graph_rag_explain(
query="Tell me about Marie Curie",
user="trustgraph",
collection="scientists"
):
if isinstance(item, RAGChunk):
response_text += item.content
print(item.content, end='', flush=True)
elif isinstance(item, ProvenanceEvent):
provenance_ids.append(item.provenance_id)
# Fetch explainability details
for prov_id in provenance_ids:
entity = explain_client.fetch_entity(
prov_id,
graph="urn:graph:retrieval",
user="trustgraph",
collection="scientists"
)
print(f"Entity: {entity}")
mcp_tool(self, name: str, parameters: Dict[str, Any], **kwargs: Any) -> Dict[str, Any]
Fanya kazi ya zana ya Itifaki ya Mfumo (MCP).
Vigezo:
name: Jina/kitambulisho cha zana
parameters: Kamusi ya vigezo vya zana
**kwargs: Vigezo vya ziada vilivyopitishwa kwa huduma
Inarudisha: dict: Matokeo ya utekelezaji wa zana
Mfano:
socket = api.socket()
flow = socket.flow("default")
result = flow.mcp_tool(
name="search-web",
parameters={"query": "latest AI news", "limit": 5}
)
prompt(self, id: str, variables: Dict[str, str], streaming: bool = False, **kwargs: Any) -> str | Iterator[str]
Tekeleza mfumo wa kielelezo cha ombi pamoja na utiririshaji wa hiari.
Vigezo:
id: Kitambulisho cha kielelezo cha ombi
variables: Kamusi ya uhusiano kati ya jina la vigezo na maadili
streaming: Washa hali ya utiririshaji (kiwango chake: Feleke)
**kwargs: Vigezo vya ziada ambavyo hutumwa kwa huduma
Inarudisha: Union[str, Iterator[str]]: Jibu kamili au mkondo wa vipande vya maandishi
Mfano:
socket = api.socket()
flow = socket.flow("default")
# Streaming prompt execution
for chunk in flow.prompt(
id="summarize-template",
variables={"topic": "quantum computing", "length": "brief"},
streaming=True
):
print(chunk, end='', flush=True)
row_embeddings_query(self, text: str, schema_name: str, user: str = 'trustgraph', collection: str = 'default', index_name: str | None = None, limit: int = 10, **kwargs: Any) -> Dict[str, Any]
Tafuta data ya safu kwa kutumia utofauti wa maana kwenye sehemu zilizofichwa.
Inatafuta safu ambazo maadili ya sehemu zilizofichwa zinafanana kwa maana na maandishi ya ingizo, kwa kutumia uelekezo wa vector. Hii inaruhusu utafutaji wa "fuzzy"/maana kwenye data iliyopangwa.
Vigezo:
text: Maandishi ya swali kwa utafutaji wa maana
schema_name: Jina la schema ili kutafuta ndani
user: Kitambulisho cha mtumiaji/keyspace (cha kawaida: "trustgraph")
collection: Kitambulisho cha mkusanyiko (cha kawaida: "default")
index_name: Jina la index la hiari ili kuchuja utafutaji kwa index maalum
limit: Nambari ya juu ya matokeo (cha kawaida: 10)
**kwargs: Vigezo vya ziada vilivyopitishwa kwa huduma
Inarudisha: dict: Matokeo ya swali ambayo yana mechi zinazojumuisha index_name, index_value, text, na score
Mfano:
socket = api.socket()
flow = socket.flow("default")
# Search for customers by name similarity
results = flow.row_embeddings_query(
text="John Smith",
schema_name="customers",
user="trustgraph",
collection="sales",
limit=5
)
# Filter to specific index
results = flow.row_embeddings_query(
text="machine learning engineer",
schema_name="employees",
index_name="job_title",
limit=10
)
rows_query(self, query: str, user: str, collection: str, variables: Dict[str, Any] | None = None, operation_name: str | None = None, **kwargs: Any) -> Dict[str, Any]
Tekeleza swali la GraphQL dhidi ya mistari iliyopangwa.
Vigezo:
query: Mnyororo wa swali la GraphQL
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
variables: Kamusi ya vigezo vya swali ya hiari
operation_name: Jina la operesheni ya hiari kwa hati za operesheni nyingi
**kwargs: Vigezo vya ziada vilivyopitishwa kwa huduma
Inarudisha: dict: Jibu la GraphQL lenye data, makosa, na/au nyongeza
Mfano:
socket = api.socket()
flow = socket.flow("default")
query = '''
{
scientists(limit: 10) {
name
field
discoveries
}
}
'''
result = flow.rows_query(
query=query,
user="trustgraph",
collection="scientists"
)
text_completion(self, system: str, prompt: str, streaming: bool = False, **kwargs) -> str | Iterator[str]
Tekeleza kukamilisha maandishi kwa kutumia utiririshaji wa hiari.
Vigezo:
system: Maelezo ya mfumo ambayo yanaelezea tabia ya msaidizi.
prompt: Maelezo ya mtumiaji/swali.
streaming: Washa hali ya utiririshaji (kiwango chachilia: False).
**kwargs: Vigezo vya ziada ambavyo hutumwa kwa huduma.
Inarudisha: Union[str, Iterator[str]]: Jibu kamili au mkondo wa vipande vya maandishi.
Mfano:
socket = api.socket()
flow = socket.flow("default")
# Non-streaming
response = flow.text_completion(
system="You are helpful",
prompt="Explain quantum computing",
streaming=False
)
print(response)
# Streaming
for chunk in flow.text_completion(
system="You are helpful",
prompt="Explain quantum computing",
streaming=True
):
print(chunk, end='', flush=True)
triples_query(self, s: str | Dict[str, Any] | None = None, p: str | Dict[str, Any] | None = None, o: str | Dict[str, Any] | None = None, g: str | None = None, user: str | None = None, collection: str | None = None, limit: int = 100, **kwargs: Any) -> List[Dict[str, Any]]
Tafuta tripli za grafu ya maarifa kwa kutumia utambuzi wa muundo.
Vigezo:
s: Kichujio cha somo - Msururu wa URI, kamusi ya neno, au None kwa kichujio cha kila kitu.
p: Kichujio cha tabia - Msururu wa URI, kamusi ya neno, au None kwa kichujio cha kila kitu.
o: Kichujio cha kitu - Msururu wa URI/lita, kamusi ya neno, au None kwa kichujio cha kila kitu.
g: Kichujio cha grafu iliyojulikana - Msururu wa URI au None kwa grafu zote.
user: Kitambulisho cha mtumiaji/nafasi (hiari).
collection: Kitambulisho cha mkusanyiko (hiari).
limit: Matokeo ya kiwango cha juu ya kurudishwa (kiwango chachilia: 100).
**kwargs: Vigezo vya ziada vilivyopitishwa kwa huduma.
Inarudisha: Orodha[Dict]: Orodha ya tripli zinazolingana katika muundo wa msingi.
Mfano:
socket = api.socket()
flow = socket.flow("default")
# Find all triples about a specific subject
triples = flow.triples_query(
s="http://example.org/person/marie-curie",
user="trustgraph",
collection="scientists"
)
# Query with named graph filter
triples = flow.triples_query(
s="urn:trustgraph:session:abc123",
g="urn:graph:retrieval",
user="trustgraph",
collection="default"
)
triples_query_stream(self, s: str | Dict[str, Any] | None = None, p: str | Dict[str, Any] | None = None, o: str | Dict[str, Any] | None = None, g: str | None = None, user: str | None = None, collection: str | None = None, limit: int = 100, batch_size: int = 20, **kwargs: Any) -> Iterator[List[Dict[str, Any]]]
Tafuta tripla za grafu ya maarifa kwa kutumia mikondo ya data.
Hutoa mikondo ya tripla kadri zinavyofika, na hivyo kupunguza muda wa kupata matokeo ya kwanza na matumizi ya kumbukumbu kwa matokeo makubwa.
Vigezo:
s: Kichujio cha mada - Msururu wa URI, kamusi ya neno, au None kwa kichujio cha wote.
p: Kichujio cha sifa - Msururu wa URI, kamusi ya neno, au None kwa kichujio cha wote.
o: Kichujio cha kitu - Msururu wa URI/lita, kamusi ya neno, au None kwa kichujio cha wote.
g: Kichujio cha grafu iliyojulikana - Msururu wa URI au None kwa grafu zote.
user: Kitambulisho cha mtumiaji/nafasi (hiari).
collection: Kitambulisho cha mkusanyiko (hiari).
limit: Matokeo mengi ya kurejesha (ya kawaida: 100).
batch_size: Tripla kwa kila kikundi (ya kawaida: 20).
**kwargs: Vigezo vya ziada vilivyopitishwa kwa huduma.
Yields:
List[Dict]: Mikundi ya tripla katika umbizo la mawasiliano.
Mfano:
socket = api.socket()
flow = socket.flow("default")
for batch in flow.triples_query_stream(
user="trustgraph",
collection="default"
):
for triple in batch:
print(triple["s"], triple["p"], triple["o"])
--
AsyncSocketClient
from trustgraph.api import AsyncSocketClient
Mteja wa WebSocket asinkroni.
Mbinu
__init__(self, url: str, timeout: int, token: str | None)
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi ya muundo.
aclose(self)
Funga muunganisho wa WebSocket.
flow(self, flow_id: str)
Pata mfumo wa kazi asinkroni kwa operesheni za WebSocket.
--
AsyncSocketFlowInstance
from trustgraph.api import AsyncSocketFlowInstance
Mfumo wa mtiririko wa WebSocket usiohusisha wakati.
Mbinu
__init__(self, client: trustgraph.api.async_socket_client.AsyncSocketClient, flow_id: str)
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi ya jinsi ya kutumia.
agent(self, question: str, user: str, state: Dict[str, Any] | None = None, group: str | None = None, history: list | None = None, streaming: bool = False, **kwargs) -> Dict[str, Any] | AsyncIterator
Wakala na utiririshaji wa hiari.
document_rag(self, query: str, user: str, collection: str, doc_limit: int = 10, streaming: bool = False, **kwargs)
Andika RAG (Retrieval-Augmented Generation) na utiririshaji wa hiari.
embeddings(self, texts: list, **kwargs)
Tengeneza ufichishaji wa maandishi.
graph_embeddings_query(self, text: str, user: str, collection: str, limit: int = 10, **kwargs)
Tafuta ufichishaji wa grafu kwa utafutaji wa maana.
graph_rag(self, query: str, user: str, collection: str, max_subgraph_size: int = 1000, max_subgraph_count: int = 5, max_entity_distance: int = 3, streaming: bool = False, **kwargs)
Grafu RAG na utiririshaji wa hiari.
mcp_tool(self, name: str, parameters: Dict[str, Any], **kwargs)
Endesha zana ya MCP.
prompt(self, id: str, variables: Dict[str, str], streaming: bool = False, **kwargs)
Endesha ombi na utiririshaji wa hiari.
row_embeddings_query(self, text: str, schema_name: str, user: str = 'trustgraph', collection: str = 'default', index_name: str | None = None, limit: int = 10, **kwargs)
Tafuta ufichishaji wa mistari kwa utafutaji wa maana kwenye data iliyopangwa.
rows_query(self, query: str, user: str, collection: str, variables: Dict | None = None, operation_name: str | None = None, **kwargs)
Ombi la GraphQL dhidi ya mistari iliyopangwa.
text_completion(self, system: str, prompt: str, streaming: bool = False, **kwargs)
Kukamilisha maandishi na utiririshaji wa hiari.
triples_query(self, s=None, p=None, o=None, user=None, collection=None, limit=100, **kwargs)
Uchunguzi wa muundo wa tatu.
--
build_term(value: Any, term_type: str | None = None, datatype: str | None = None, language: str | None = None) -> Dict[str, Any] | None
Jenga kamusi ya Term ya muundo kutoka kwa thamani.
Kanuni za utambuzi wa kiotomatiki (wakati term_type ni None):
Tayari ni kamusi yenye ufunguo 't' -> irudishe kama ilivyo (tayari ni Term)
Inaanzia na http://, https://, urn: -> IRI
Imezungushwa ndani ya <> (e.g., http://...) -> IRI (brashi za pembe zimeondolewa)
Kila kitu kingine -> literal
Majadiliano:
value: Thamani ya Term (mfululizo, kamusi, au None)
term_type: Moja kati ya 'iri', 'literal', au None kwa utambuzi wa kiotomatiki
datatype: Aina ya data kwa vitu vya literal (e.g., xsd:integer)
language: Lango la lugha kwa vitu vya literal (e.g., en)
Inarudisha: kamusi: Kamusi ya Term ya muundo, au None ikiwa thamani ni None
--
BulkClient
from trustgraph.api import BulkClient
Mteja wa operesheni za wingi za wakati mmoja kwa uagizaji/utoaji.
Hutoa uhamishaji wa data wa wingi unaofaa kupitia WebSocket kwa data kubwa. Huweka operesheni za WebSocket za asinkroni na jenereta za wakati mmoja ili kupunguza ugumu.
Kumbuka: Kwa usaidizi halisi wa asinkroni, tumia AsyncBulkClient badala yake.
Mbinu
__init__(self, url: str, timeout: int, token: str | None) -> None
Anzisha mteja wa wingi wa wakati mmoja.
Majadilisho:
url: URL ya msingi kwa API ya TrustGraph (HTTP/HTTPS itabadilishwa kuwa WS/WSS)
timeout: Muda wa timeout wa WebSocket kwa sekunde
token: Tokeni ya kuhifadhiwa ya hiari kwa uthibitishaji
close(self) -> None
Funga miunganisho
export_document_embeddings(self, flow: str, **kwargs: Any) -> Iterator[Dict[str, Any]]
Toa nakala za uainishaji kutoka kwa mtiririko.
Inapakua kwa ufanisi uainishaji wote wa vipande vya nyaraka kupitia utiririshaji wa WebSocket.
Majadilisho:
flow: Kitambulisho cha mtiririko
**kwargs: Vigezo vya ziada (hifadhiwa kwa matumizi ya baadaye)
Inarudisha: Iterator[Dict[str, Any]]: Msururu wa kamusi za uainishaji
Mfano:
bulk = api.bulk()
# Export and process document embeddings
for embedding in bulk.export_document_embeddings(flow="default"):
chunk_id = embedding.get("chunk_id")
vector = embedding.get("embedding")
print(f"{chunk_id}: {len(vector)} dimensions")
export_entity_contexts(self, flow: str, **kwargs: Any) -> Iterator[Dict[str, Any]]
Uhamisho wa wingi wa muktadha wa vitu kutoka kwa mtiririko.
Inapakua habari yote ya muktadha wa vitu kwa ufanisi kupitia utiririshaji wa WebSocket.
Vigezo:
flow: Kitambulisho cha mtiririko
**kwargs: Vigezo vya ziada (hifadhiwa kwa matumizi ya baadaye)
Inarudisha: Iterator[Dict[str, Any]]: Msururu wa kamusi za muktadha
Mfano:
bulk = api.bulk()
# Export and process entity contexts
for context in bulk.export_entity_contexts(flow="default"):
entity = context.get("entity")
text = context.get("context")
print(f"{entity}: {text[:100]}...")
export_graph_embeddings(self, flow: str, **kwargs: Any) -> Iterator[Dict[str, Any]]
Uhamisho wa wingi wa maandamano ya grafu kutoka kwa mtiririko.
Inapakua kwa ufanisi maandamano yote ya vitu vya grafu kupitia utiririshaji wa WebSocket.
Vigezo:
flow: Kitambulisho cha mtiririko
**kwargs: Vigezo vya ziada (hifadhiwa kwa matumizi ya baadaye)
Inarudisha: Iterator[Dict[str, Any]]: Mto wa kamusi za maandamano
Mfano:
bulk = api.bulk()
# Export and process embeddings
for embedding in bulk.export_graph_embeddings(flow="default"):
entity = embedding.get("entity")
vector = embedding.get("embedding")
print(f"{entity}: {len(vector)} dimensions")
export_triples(self, flow: str, **kwargs: Any) -> Iterator[trustgraph.api.types.Triple]
Uhamisho wa wingi wa data ya RDF kutoka kwa mtiririko.
Inapakua data yote kwa ufanisi kupitia utiririshaji wa WebSocket.
Vigezo:
flow: Kitambulisho cha mtiririko.
**kwargs: Vigezo vya ziada (hifadhiwa kwa matumizi ya baadaye).
Inarudisha: Iterator[Triple]: Mto wa vitu vya Triple.
Mfano:
bulk = api.bulk()
# Export and process triples
for triple in bulk.export_triples(flow="default"):
print(f"{triple.s} -> {triple.p} -> {triple.o}")
import_document_embeddings(self, flow: str, embeddings: Iterator[Dict[str, Any]], **kwargs: Any) -> None
Kuleta kwa wingi maandishi ya kuingizwa katika mtiririko.
Huainisha kwa ufanisi maandishi ya vipande vya maandishi kupitia utiririshaji wa WebSocket kwa matumizi katika maswali ya RAG ya maandishi.
Vigezo:
flow: Kitambulisho cha mtiririko
embeddings: Mfumo unaotoa kamusi za kuingizwa
**kwargs: Vigezo vya ziada (hifadhiwa kwa matumizi ya baadaye)
Mfano:
bulk = api.bulk()
# Generate document embeddings to import
def doc_embedding_generator():
yield {"chunk_id": "doc1/p0/c0", "embedding": [0.1, 0.2, ...]}
yield {"chunk_id": "doc1/p0/c1", "embedding": [0.3, 0.4, ...]}
# ... more embeddings
bulk.import_document_embeddings(
flow="default",
embeddings=doc_embedding_generator()
)
import_entity_contexts(self, flow: str, contexts: Iterator[Dict[str, Any]], metadata: Dict[str, Any] | None = None, batch_size: int = 100, **kwargs: Any) -> None
Kuleta kwa wingi maelezo ya vitu ndani ya mtiririko.
Huwezesha kupakia taarifa za maelezo ya vitu kupitia utiririshaji wa WebSocket. Maelezo ya vitu hutoa maelezo ya ziada ya maandishi kuhusu vitu vya chati ili kuboresha utendaji wa RAG.
Vigezo:
flow: Kitambulisho cha mtiririko
contexts: Iteratili inayotoa kamusi za maelezo
metadata: Kamusi ya metadata yenye id, metadata, mtumiaji, mkusanyiko
batch_size: Idadi ya maelezo kwa kila kundi (ya kawaida 100)
**kwargs: Vigezo vya ziada (vimehifadhiwa kwa matumizi ya baadaye)
Mfano:
bulk = api.bulk()
# Generate entity contexts to import
def context_generator():
yield {"entity": {"v": "entity1", "e": True}, "context": "Description..."}
yield {"entity": {"v": "entity2", "e": True}, "context": "Description..."}
# ... more contexts
bulk.import_entity_contexts(
flow="default",
contexts=context_generator(),
metadata={"id": "doc1", "metadata": [], "user": "user1", "collection": "default"}
)
import_graph_embeddings(self, flow: str, embeddings: Iterator[Dict[str, Any]], **kwargs: Any) -> None
Kuleta kwa wingi michoro ya pembejeo katika mtiririko.
Huainisha kwa ufanisi pembejeo za michoro kupitia utiririshaji wa WebSocket.
Vigezo:
flow: Kitambulisho cha mtiririko
embeddings: Mfuatiliao unaotoa kamusi za pembejeo
**kwargs: Vigezo vya ziada (hifadhiwa kwa matumizi ya baadaye)
Mfano:
bulk = api.bulk()
# Generate embeddings to import
def embedding_generator():
yield {"entity": "entity1", "embedding": [0.1, 0.2, ...]}
yield {"entity": "entity2", "embedding": [0.3, 0.4, ...]}
# ... more embeddings
bulk.import_graph_embeddings(
flow="default",
embeddings=embedding_generator()
)
import_rows(self, flow: str, rows: Iterator[Dict[str, Any]], **kwargs: Any) -> None
Kuingiza kwa wingi mistari iliyoandaliwa katika mtiririko.
Inapakia data iliyoandaliwa kwa ufanisi kupitia utiririshaji wa WebSocket kwa ajili ya matumizi katika maswali ya GraphQL.
Vigezo:
flow: Kitambulisho cha mtiririko
rows: Mfuatiliazo unaotoa kamusi za mistari
**kwargs: Vigezo vya ziada (hifadhiwa kwa matumizi ya baadaye)
Mfano:
bulk = api.bulk()
# Generate rows to import
def row_generator():
yield {"id": "row1", "name": "Row 1", "value": 100}
yield {"id": "row2", "name": "Row 2", "value": 200}
# ... more rows
bulk.import_rows(
flow="default",
rows=row_generator()
)
import_triples(self, flow: str, triples: Iterator[trustgraph.api.types.Triple], metadata: Dict[str, Any] | None = None, batch_size: int = 100, **kwargs: Any) -> None
Uingizaji wa jumla wa triplet za RDF katika mtiririko.
Huainisha triplet nyingi kwa ufanisi kupitia utiririshaji wa WebSocket.
Vigezo:
flow: Kitambulisho cha mtiririko
triples: Itereta inayotoa vitu vya Triple
metadata: Kamusi ya metadata yenye id, metadata, mtumiaji, mkusanyiko
batch_size: Idadi ya triplet kwa kila kundi (ya kawaida 100)
**kwargs: Vigezo vya ziada (vimehifadhiwa kwa matumizi ya baadaye)
Mfano:
from trustgraph.api import Triple
bulk = api.bulk()
# Generate triples to import
def triple_generator():
yield Triple(s="subj1", p="pred", o="obj1")
yield Triple(s="subj2", p="pred", o="obj2")
# ... more triples
# Import triples
bulk.import_triples(
flow="default",
triples=triple_generator(),
metadata={"id": "doc1", "metadata": [], "user": "user1", "collection": "default"}
)
--
AsyncBulkClient
from trustgraph.api import AsyncBulkClient
Mteja wa operesheni za wingi zisizo za wakati.
Mbinu
__init__(self, url: str, timeout: int, token: str | None) -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi ya muundo.
aclose(self) -> None
Funga miunganisho.
export_document_embeddings(self, flow: str, **kwargs: Any) -> AsyncIterator[Dict[str, Any]]
Uhamisho wa wingi wa maandishi ya nyaraka kupitia WebSocket.
export_entity_contexts(self, flow: str, **kwargs: Any) -> AsyncIterator[Dict[str, Any]]
Uhamisho wa wingi wa muktadha wa vitu kupitia WebSocket.
export_graph_embeddings(self, flow: str, **kwargs: Any) -> AsyncIterator[Dict[str, Any]]
Uhamisho wa wingi wa maandishi ya chati kupitia WebSocket.
export_triples(self, flow: str, **kwargs: Any) -> AsyncIterator[trustgraph.api.types.Triple]
Uhamisho wa wingi wa triplet kupitia WebSocket.
import_document_embeddings(self, flow: str, embeddings: AsyncIterator[Dict[str, Any]], **kwargs: Any) -> None
Uingizaji wa wingi wa maandishi ya nyaraka kupitia WebSocket.
import_entity_contexts(self, flow: str, contexts: AsyncIterator[Dict[str, Any]], **kwargs: Any) -> None
Uingizaji wa wingi wa muktadha wa vitu kupitia WebSocket.
import_graph_embeddings(self, flow: str, embeddings: AsyncIterator[Dict[str, Any]], **kwargs: Any) -> None
Uingizaji wa wingi wa maandishi ya chati kupitia WebSocket.
import_rows(self, flow: str, rows: AsyncIterator[Dict[str, Any]], **kwargs: Any) -> None
Uingizaji wa wingi wa mistari kupitia WebSocket.
import_triples(self, flow: str, triples: AsyncIterator[trustgraph.api.types.Triple], **kwargs: Any) -> None
Uingizaji wa wingi wa triplet kupitia WebSocket.
--
Metrics
from trustgraph.api import Metrics
Mteja wa metriki za wakati mmoja.
Mbinu
__init__(self, url: str, timeout: int, token: str | None) -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi ya muundo.
get(self) -> str
Pata metriki za Prometheus kama maandishi.
--
AsyncMetrics
from trustgraph.api import AsyncMetrics
Mteja wa metriki zisizo za wakati (asynchronous).
Mbinu (Methods)
__init__(self, url: str, timeout: int, token: str | None) -> None
Anzisha (Initialize) self. Angalia help(type(self)) kwa maelezo sahihi ya muundo.
aclose(self) -> None
Funga miunganisho (Close connections).
get(self) -> str
Pata metriki za Prometheus kama maandishi (Get Prometheus metrics as text).
--
ExplainabilityClient
from trustgraph.api import ExplainabilityClient
Mteja wa kupata vitu vya uhalisia kwa utaratibu wa utangamano wa mwisho.
Hutumia utambuzi wa utulivu: pata, subiri, pata tena, linganisha. Ikiwa matokeo ni sawa, data ni thabiti.
Mbinu
__init__(self, flow_instance, retry_delay: float = 0.2, max_retries: int = 10)
Anzisha mteja wa uhalisia.
Majadiliano:
flow_instance: Toleo la SocketFlowInstance kwa kuuliza vitatu.
retry_delay: Kuchelewesha kati ya majaribio katika sekunde (kiwango chote: 0.2).
max_retries: Jaribio la juu zaidi (kiwango chote: 10).
detect_session_type(self, session_uri: str, graph: str | None = None, user: str | None = None, collection: str | None = None) -> str
Thibitisha ikiwa kikao ni cha aina ya GraphRAG au Agent.
Vigezo:
session_uri: URI ya kipindi/swali
graph: Grafu iliyopewa jina
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
Inarudisha: "graphrag" au "agent"
fetch_agent_trace(self, session_uri: str, graph: str | None = None, user: str | None = None, collection: str | None = None, api: Any = None, max_content: int = 10000) -> Dict[str, Any]
Pata faili kamili ya "Agent" kuanzia URI ya kipindi.
Fuata mnyororo wa asili: Swali -> Uchambuzi(s) -> Hitimisho
Vigezo:
session_uri: URI ya kipindi cha "agent"/swali
graph: Grafu iliyopewa jina (ya kawaida: urn:graph:retrieval)
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
api: Ena ya TrustGraph API kwa ufikiaji wa "librarian" (hiari)
max_content: Urefu wa juu wa maudhui kwa hitimisho
Inarudi: Kamusi yenye swali, mara (Orodha ya uchambuzi), na vitu vya hitimisho.
fetch_docrag_trace(self, question_uri: str, graph: str | None = None, user: str | None = None, collection: str | None = None, api: Any = None, max_content: int = 10000) -> Dict[str, Any]
Kuchukua faili kamili ya "DocumentRAG" kuanzia URI ya swali.
Kufuata mnyororo wa asili: Swali -> Msingi -> Uchunguzi -> Muunganisho
Majadiliano:
question_uri: URI ya swali.
graph: Grafu iliyoitwa (ya kawaida: urn:graph:retrieval).
user: Kitambulisho cha mtumiaji/nafasi.
collection: Kitambulisho cha mkusanyiko.
api: Eneo la TrustGraph API kwa ufikiaji wa "librarian" (hiari).
max_content: Urefu wa juu wa yaliyomo kwa muunganisho.
Inarudi: Kamusi yenye swali, msingi, uchunguzi, na vitu vya muunganisho.
fetch_document_content(self, document_uri: str, api: Any, user: str | None = None, max_content: int = 10000) -> str
Kuchukua yaliyomo kutoka kwa "librarian" kwa URI ya hati.
Majadiliano:
document_uri: URI ya hati katika "librarian".
api: Eneo la TrustGraph API kwa ufikiaji wa "librarian".
user: Kitambulisho cha mtumiaji kwa "librarian".
max_content: Urefu wa juu wa yaliyomo yanayorudishwa.
Inarudi: Yaliyomo ya hati kama mfululizo.
fetch_edge_selection(self, uri: str, graph: str | None = None, user: str | None = None, collection: str | None = None) -> trustgraph.api.explainability.EdgeSelection | None
Kuchukua kitambulisho cha uchaguzi wa "edge" (kinachotumika na Focus).
Majadiliano:
uri: URI ya uchaguzi wa "edge".
graph: Grafu iliyoitwa ya kuchunguza.
user: Kitambulisho cha mtumiaji/nafasi.
collection: Kitambulisho cha mkusanyiko.
Inarudi: EdgeSelection au None ikiwa haipatikani.
fetch_entity(self, uri: str, graph: str | None = None, user: str | None = None, collection: str | None = None) -> trustgraph.api.explainability.ExplainEntity | None
Kuchukua na kueleza kitu (entity) kwa kutumia URI, na kusimamia utaratibu wa uthabiti.
Hutumia utambuzi wa utulivu:
- Kuchukua data (triples) kwa URI
- Ikiwa hakuna matokeo, jaribu tena
- Ikiwa kuna matokeo, subiri na chukua tena
- Ikiwa matokeo ni sawa, data imetulia - changanua na urudishe
- Ikiwa matokeo ni tofauti, data bado inaanzishwa - jaribu tena
Vigezo:
uri: URI ya kitu (entity) kinachohitajika
graph: Picha (graph) inayotumika kwa utafutaji (e.g., "urn:graph:retrieval")
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
Inarudisha: Kifaa cha aina ya ExplainEntity au None ikiwa haipatikani
fetch_focus_with_edges(self, uri: str, graph: str | None = None, user: str | None = None, collection: str | None = None) -> trustgraph.api.explainability.Focus | None
Kuchukua kitu (entity) cha "Focus" na uteuzi wake wote wa "edge".
Vigezo:
uri: URI ya kitu (entity) cha "Focus"
graph: Picha (graph) inayotumika kwa utafutaji
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
Inarudisha: "Focus" iliyo na "edge_selections" zilizojazwa, au None
fetch_graphrag_trace(self, question_uri: str, graph: str | None = None, user: str | None = None, collection: str | None = None, api: Any = None, max_content: int = 10000) -> Dict[str, Any]
Kuchukua "GraphRAG" kamili kuanzia URI ya swali.
Ifuatilia mnyororo wa asili: Swali -> Uthabiti -> Uchunguzi -> Focus -> Muhtasari
Vigezo:
question_uri: URI ya swali
graph: Picha (default: urn:graph:retrieval)
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
api: Ena ya TrustGraph API kwa ufikiaji wa "librarian" (hiari)
max_content: Urefu wa juu wa yaliyomo kwa ajili ya muhtasari
Inarudisha: Kamusi yenye vitu vya swali, msingi, uchunguzi, lengo, na muhtasari.
list_sessions(self, graph: str | None = None, user: str | None = None, collection: str | None = None, limit: int = 50) -> List[trustgraph.api.explainability.Question]
Orodha ya vipindi vyote vya kufafanua (maswali) katika mkusanyiko.
Majadiliano:
graph: Picha iliyopewa jina (ya kawaida: urn:graph:retrieval)
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
limit: Nambari ya juu ya vipindi kurudishwa
Inarudisha: Orodha ya vitu vya Swali vilivyopangwa kwa wakati (vya hivi karibuni kwanza)
resolve_edge_labels(self, edge: Dict[str, str], user: str | None = None, collection: str | None = None) -> Tuple[str, str, str]
Tatua lebo kwa vipengele vyote vya triplet ya ukingo.
Majadiliano:
edge: Kamusi yenye funguo za "s", "p", na "o"
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
Inarudisha: Jozi ya (s_label, p_label, o_label)
resolve_label(self, uri: str, user: str | None = None, collection: str | None = None) -> str
Tatua rdfs:label kwa URI, pamoja na kuhifadhi.
Majadiliano:
uri: URI ambayo lebo inapaswa kupatikana
user: Kitambulisho cha mtumiaji/nafasi
collection: Kitambulisho cha mkusanyiko
Inarudisha: Lebo ikiwa imepatikana, vinginevyo URI yenyewe.
--
ExplainEntity
from trustgraph.api import ExplainEntity
Darasa la msingi kwa vitu vya uelewaji.
Vipengele:
uri: <class 'str'>
entity_type: <class 'str'>
Mbinu
__init__(self, uri: str, entity_type: str = '') -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi.
--
Question
from trustgraph.api import Question
Swali la mtumiaji - swali la mtumiaji ambalo lilianzisha kipindi.
Vifaa:
uri: <class 'str'>
entity_type: <class 'str'>
query: <class 'str'>
timestamp: <class 'str'>
question_type: <class 'str'>
Mbinu
__init__(self, uri: str, entity_type: str = '', query: str = '', timestamp: str = '', question_type: str = '') -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi.
--
Exploration
from trustgraph.api import Exploration
Kitengo cha utafiti - pembejeo/sehemu zilizopatikana kutoka kwenye hifadhi ya maarifa.
Vifaa:
uri: <class 'str'>
entity_type: <class 'str'>
edge_count: <class 'int'>
chunk_count: <class 'int'>
entities: typing.List[str]
Mbinu
__init__(self, uri: str, entity_type: str = '', edge_count: int = 0, chunk_count: int = 0, entities: List[str] = <factory>) -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi ya muundo.
--
Focus
from trustgraph.api import Focus
Mfumo wa msingi - pembe zilizochaguliwa pamoja na utaratibu wa akili wa LLM (GraphRAG pekee).
Sehemu:
uri: <class 'str'>
entity_type: <class 'str'>
selected_edge_uris: typing.List[str]
edge_selections: typing.List[trustgraph.api.explainability.EdgeSelection]
Mbinu
__init__(self, uri: str, entity_type: str = '', selected_edge_uris: List[str] = <factory>, edge_selections: List[trustgraph.api.explainability.EdgeSelection] = <factory>) -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi ya muundo.
--
Synthesis
from trustgraph.api import Synthesis
Kitengo cha muhtasari - jibu la mwisho.
Sehemu:
uri: <class 'str'>
entity_type: <class 'str'>
document: <class 'str'>
Mbinu
__init__(self, uri: str, entity_type: str = '', document: str = '') -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi.
--
Analysis
from trustgraph.api import Analysis
Kitengo cha uchambuzi - mzunguko mmoja wa kufikiria/kutenda/kuchunguza (Kwa wakala pekee).
Vyunzo:
uri: <class 'str'>
entity_type: <class 'str'>
action: <class 'str'>
arguments: <class 'str'>
thought: <class 'str'>
observation: <class 'str'>
Mbinu
__init__(self, uri: str, entity_type: str = '', action: str = '', arguments: str = '', thought: str = '', observation: str = '') -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi ya muundo.
--
Conclusion
from trustgraph.api import Conclusion
Hitimisho la kitengo - jibu la mwisho (Kwa wakala pekee).
Sehemu:
uri: <class 'str'>
entity_type: <class 'str'>
document: <class 'str'>
Mbinu
__init__(self, uri: str, entity_type: str = '', document: str = '') -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi.
--
EdgeSelection
from trustgraph.api import EdgeSelection
Kichwa kilichochaguliwa pamoja na hoja kutoka hatua ya GraphRAG Focus.
Sehemu:
uri: <class 'str'>
edge: typing.Dict[str, str] | None
reasoning: <class 'str'>
Mbinu
__init__(self, uri: str, edge: Dict[str, str] | None = None, reasoning: str = '') -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi ya muundo.
--
wire_triples_to_tuples(wire_triples: List[Dict[str, Any]]) -> List[Tuple[str, str, Any]]
Badilisha triplet katika umbizo la waya kuwa tuples za (s, p, o).
--
extract_term_value(term: Dict[str, Any]) -> Any
Toa thamani kutoka kwenye kamusi ya Term katika umbizo la waya.
--
Triple
from trustgraph.api import Triple
Mfumo wa data wa RDF unaoonyesha sentensi ya grafu ya maarifa.
Sehemu:
s: <class 'str'>
p: <class 'str'>
o: <class 'str'>
Mbinu
__init__(self, s: str, p: str, o: str) -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi ya muundo.
--
Uri
from trustgraph.api import Uri
str(object='') -> str str(bytes_or_buffer[, encoding[, errors]]) -> str
Unda mnyororo mpya kutoka kwa kitu kilichopewa. Ikiwa encoding au errors imebainishwa, basi kitu lazima kiwe na buffer ya data ambayo itafichuliwa kwa kutumia encoding iliyopewa na kidhibiti cha makosa. Vinginevyo, hurudia matokeo ya kitu.str() (ikiwa imefafanuliwa) au repr(kitu). encoding huwezeshwa kuwa 'utf-8'. errors huwezeshwa kuwa 'strict'.
Mbinu
is_literal(self)
is_triple(self)
is_uri(self)
--
Literal
from trustgraph.api import Literal
str(object='') -> str str(bytes_or_buffer[, encoding[, errors]]) -> str
Unda mnyororo mpya kutoka kwa kitu kilichopewa. Ikiwa encoding au errors imebainishwa, basi kitu lazima kiwe na buffer ya data ambayo itafichuliwa kwa kutumia usimbaji (encoding) na kidhibiti cha makosa (error handler) uliobainishwa. Vinginevyo, hurudia matokeo ya kitu.str() (ikiwa imefafanuliwa) au repr(object). usimbaji (encoding) huanguka kwa 'utf-8'. makosa (errors) huanguka kwa 'strict'.
Mbinu
is_literal(self)
is_triple(self)
is_uri(self)
--
ConfigKey
from trustgraph.api import ConfigKey
Kitambulisho cha ufunguo wa usanidi.
Sehemu:
type: <class 'str'>
key: <class 'str'>
Mbinu
__init__(self, type: str, key: str) -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi.
--
ConfigValue
from trustgraph.api import ConfigValue
Jozi ya ufunguo na thamani ya usanidi.
Sehemu:
type: <class 'str'>
key: <class 'str'>
value: <class 'str'>
Mbinu
__init__(self, type: str, key: str, value: str) -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi.
--
DocumentMetadata
from trustgraph.api import DocumentMetadata
Meta data kwa hati katika maktaba.
Sifa:
parent_id: Parent document ID for child documents (empty for top: ngazi ya hati
Nafasi:
id: <class 'str'>
time: <class 'datetime.datetime'>
kind: <class 'str'>
title: <class 'str'>
comments: <class 'str'>
metadata: typing.List[trustgraph.api.types.Triple]
user: <class 'str'>
tags: typing.List[str]
parent_id: <class 'str'>
document_type: <class 'str'>
Mbinu
__init__(self, id: str, time: datetime.datetime, kind: str, title: str, comments: str, metadata: List[trustgraph.api.types.Triple], user: str, tags: List[str], parent_id: str = '', document_type: str = 'source') -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi ya muundo.
--
ProcessingMetadata
from trustgraph.api import ProcessingMetadata
Meta data kwa kazi ya usindikaji hati inayofanya kazi.
Vyunzo:
id: <class 'str'>
document_id: <class 'str'>
time: <class 'datetime.datetime'>
flow: <class 'str'>
user: <class 'str'>
collection: <class 'str'>
tags: typing.List[str]
Mbinu
__init__(self, id: str, document_id: str, time: datetime.datetime, flow: str, user: str, collection: str, tags: List[str]) -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi ya muundo.
--
CollectionMetadata
from trustgraph.api import CollectionMetadata
Meta data kwa mkusanyiko wa data.
Mikusanyiko hutoa uainishaji na kutenganisha kwa mantiki kwa hati na data ya mfumo wa maarifa.
Sifa:
name: Human: jina la mkusanyiko linalosoma
Nafasi:
user: <class 'str'>
collection: <class 'str'>
name: <class 'str'>
description: <class 'str'>
tags: typing.List[str]
Mbinu
__init__(self, user: str, collection: str, name: str, description: str, tags: List[str]) -> None
Anzisha self. Angalia help(type(self)) kwa saini sahihi.
--
StreamingChunk
from trustgraph.api import StreamingChunk
Darasa la msingi kwa ajili ya vipande vya majibu yanayotumwa.
Hutumika kwa operesheni za utiririshaji zinazotegemea WebSocket ambapo majibu hutolewa hatua kwa hatua yanapozalishwa.
Vipengele:
content: <class 'str'>
end_of_message: <class 'bool'>
Njia
__init__(self, content: str, end_of_message: bool = False) -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi.
--
AgentThought
from trustgraph.api import AgentThought
Sehemu ya hoja au mchakato wa kufikiri wa wakala.
Inawakilisha hoja au hatua za upangaji za ndani za wakala wakati wa utekelezaji. Sehemu hizi zinaonyesha jinsi wakala anavyofikiri kuhusu tatizo.
Vifaa:
content: <class 'str'>
end_of_message: <class 'bool'>
chunk_type: <class 'str'>
Mbinu
__init__(self, content: str, end_of_message: bool = False, chunk_type: str = 'thought') -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi ya muundo.
--
AgentObservation
from trustgraph.api import AgentObservation
Sehemu ya matokeo au uchunguzi wa matumizi ya zana.
Inawakilisha matokeo au uchunguzi kutoka kwa matumizi ya zana au kitendo. Sehemu hizi zinaonyesha kile ambacho wakala alijifunza kutokana na matumizi ya zana.
Vifaa:
content: <class 'str'>
end_of_message: <class 'bool'>
chunk_type: <class 'str'>
Mbinu
__init__(self, content: str, end_of_message: bool = False, chunk_type: str = 'observation') -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi ya muundo.
--
AgentAnswer
from trustgraph.api import AgentAnswer
Sehemu ya jibu la mwisho la wakala.
Inawakilisha jibu la mwisho la wakala kwa swali la mtumiaji baada ya kukamilisha utaratibu wake na matumizi ya zana.
Sifa:
chunk_type: Always "final: jibu"
Nafasi:
content: <class 'str'>
end_of_message: <class 'bool'>
chunk_type: <class 'str'>
end_of_dialog: <class 'bool'>
Mbinu
__init__(self, content: str, end_of_message: bool = False, chunk_type: str = 'final-answer', end_of_dialog: bool = False) -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi ya muundo.
--
RAGChunk
from trustgraph.api import RAGChunk
Sehemu inayotumika kwa utiririshaji ya RAG (Uundaji Ulioboreshwa na Urekebishaji).
Inatumika kwa utiririshaji wa majibu kutoka kwa RAG ya grafu, RAG ya hati, kukamilisha maandishi, na huduma zingine za uundaji.
Vipengele:
content: <class 'str'>
end_of_message: <class 'bool'>
chunk_type: <class 'str'>
end_of_stream: <class 'bool'>
error: typing.Dict[str, str] | None
Mbinu
__init__(self, content: str, end_of_message: bool = False, chunk_type: str = 'rag', end_of_stream: bool = False, error: Dict[str, str] | None = None) -> None
Anzisha self. Angalia help(type(self)) kwa maelezo sahihi ya muundo.
--
ProvenanceEvent
from trustgraph.api import ProvenanceEvent
Tukio la asili kwa ajili ya uelewaji.
Hutolewa wakati wa maswali ya GraphRAG wakati hali ya uelewaji imeanzishwa. Kila tukio linawakilisha nodi ya asili iliyoundwa wakati wa uchakataji wa swali.
Vifaa:
explain_id: <class 'str'>
explain_graph: <class 'str'>
event_type: <class 'str'>
Mbinu
__init__(self, explain_id: str, explain_graph: str = '', event_type: str = '') -> None
Anzisha self. Angalia help(type(self)) kwa ajili ya saini sahihi.
--
ProtocolException
from trustgraph.api import ProtocolException
Inayotokea wakati wa hitilafu za itifaki ya WebSocket.
--
TrustGraphException
from trustgraph.api import TrustGraphException
Darasa la msingi kwa makosa yote ya huduma ya TrustGraph.
--
AgentError
from trustgraph.api import AgentError
Kosa la huduma ya wakala.
--
ConfigError
from trustgraph.api import ConfigError
Kosa la huduma ya usanidi.
--
DocumentRagError
from trustgraph.api import DocumentRagError
Kosa la upokeaji wa hati kutoka kwa mfumo.
--
FlowError
from trustgraph.api import FlowError
Kosa la usimamizi wa mtiririko
--
GatewayError
from trustgraph.api import GatewayError
Kosa la API Gateway
--
GraphRagError
from trustgraph.api import GraphRagError
Kosa la urejesho la mfumo wa RAG.
--
LLMError
from trustgraph.api import LLMError
Kosa la huduma ya LLM.
--
LoadError
from trustgraph.api import LoadError
Kosa la kupakia data.
--
LookupError
from trustgraph.api import LookupError
Kosa la utafutaji/tazama.
--
NLPQueryError
from trustgraph.api import NLPQueryError
Kosa la huduma ya utafutaji kwa lugha.
--
RowsQueryError
from trustgraph.api import RowsQueryError
Kosa la huduma ya utafutaji wa data.
--
RequestError
from trustgraph.api import RequestError
Kosa katika usindikaji wa ombi.
--
StructuredQueryError
from trustgraph.api import StructuredQueryError
Kosa la huduma ya maswali iliyopangwa.
--
UnexpectedError
from trustgraph.api import UnexpectedError
Kosa lisilotarajiwa/lisilojulikana.
--
ApplicationException
from trustgraph.api import ApplicationException
Darasa la msingi kwa makosa yote ya huduma ya TrustGraph.
--