ts_llmlib - TrustedSec LLM Library

TrustedSec LLM Library ist eine Python-Bibliothek für die Interaktion mit lokalen LLMs, die Tool-Nutzung unterstützen. Sie ermöglicht die Ausführung großer Workflows, die traditionell nur mit Frontier-Modellen möglich waren, indem sie lokale LLM-Endpunkte und die Integration von MCP (Model Context Protocol) nutzt.

Funktionen

Unterstützung lokaler LLMs: Verbindung zu jedem OpenAI-kompatiblen API-Endpunkt oder Nutzung lokaler LLM-Server
MCP-Integration: Vollständige Model-Context-Protocol-Unterstützung sowohl für RPC- als auch für SSE-Protokolle
Tool-Registry: Integrierte Tools für Dateioperationen mit Erweiterbarkeit für benutzerdefinierte Tools
Gesprächsverlauf: Chat-Kontext über mehrere Runden hinweg beibehalten
Zeitlimits: Konfigurierbare Ausführungs-Timeouts, um unkontrollierte Operationen zu verhindern
Reines Python: Keine externen Abhängigkeiten über die Standardbibliothek hinaus

Installation

Als Python-Paket

# Repository klonen oder kopieren
git clone https://github.com/trustedsec/ts_llmlib.git
cd ts_llmlib

# Mit pip installieren
pip install -e .

Manuelle Installation

Kopieren Sie das Verzeichnis ts_llmlib/ in Ihr Projekt:

cp -rf ts_llmlib /path/to/your/project/

Schnellstart

Grundlegende Verwendung

from ts_llmlib import ChatSession

# Mit Standardwerten initialisieren (verbindet sich mit http://localhost:1234/v1/chat/completions)
chat = ChatSession()

# Einen Prompt ausführen
response = chat.run_prompt("What files are in the current directory?")
print(response['content'])

Mit benutzerdefinierter Konfiguration

from ts_llmlib import ChatSession

# Mit benutzerdefinierten Einstellungen konfigurieren
chat = ChatSession(
    system_prompt="You are a helpful assistant that uses file tools.",
    tool_list=[],  # Leer = Standard-Datei-Tools verwenden
    mcp_servers={
        "default": "http://localhost:3000/mcp"
    },
    llm_endpoint_url="http://localhost:1234/v1/chat/completions",
    model_name="qwen3-coder-next",
    timeout=60,
    max_runtime=300
)

response = chat.run_prompt("Write 'hello' to /tmp/greeting.txt")
print(response['content'])

Mit Gesprächsverlauf

from ts_llmlib import ChatSession

chat = ChatSession()

history = [
    {"role": "user", "content": "What is 2+2?"},
    {"role": "assistant", "content": "The answer is 4."}
]

response = chat.run_prompt("Can you write that to a file?", history=history)

Integrierte Tools

MCP-Integration

MCP (Model Context Protocol) ermöglicht die Integration externer Tools und Dienste. Wenn MCP-Server konfiguriert sind, wird ts_llmlib:

Verbindungen zu jedem Server initialisieren
Verfügbare Tools vom Server abrufen
Sie mit den integrierten Tools zusammenführen (MCP-Tools haben bei übereinstimmenden Namen Vorrang)
Tool-Aufrufe über den entsprechenden Server ausführen

Beispiel mit Ghidra-MCP-Server

from ts_llmlib import ChatSession

chat = ChatSession(
    mcp_servers={
        "ghidraSvr": "http://localhost:8081/sse"
    },
    llm_endpoint_url="http://localhost:1234/v1/chat/completions",
    model_name="qwen3-coder-next"
)

# Die Chat-Sitzung ruft automatisch Ghidra-Tools ab und integriert sie,
# z. B. list_methods, decompile_function, get_xrefs_to usw.

MCP-Server-Endpunkte

ts_llmlib unterstützt sowohl RPC- als auch SSE-Endpunkte (Server-Sent Events):

RPC: http://localhost:3000/mcp
SSE: http://localhost:3000/sse (wird für RPC-Aufrufe automatisch zu /mcp konvertiert)

API-Referenz

ChatSession-Klasse

ChatSession(
    system_prompt: str | None = None,
    tool_list: list | None = None,
    mcp_servers: dict[str, str] | None = None,
    llm_endpoint_url: str = "http://localhost:1234/v1/chat/completions",
    model_name: str = "default",
    timeout: int = 60,
    max_runtime: int = 300
)

Parameter:

system_prompt (str | None): Benutzerdefinierter System-Prompt. Standardmäßig wird ein minimaler Assistant-Prompt verwendet.
tool_list (list | None): Liste benutzerdefinierter Tool-Definitionen. Eine leere Liste verwendet die integrierten Tools.
mcp_servers (dict[str, str] | None): Dict, das Servernamen auf URLs abbildet.
llm_endpoint_url (str): URL des LLM-API-Endpunkts.
model_name (str): Modellbezeichner für den LLM-Endpunkt.
timeout (int): HTTP-Request-Timeout in Sekunden.
max_runtime (int): Maximale Ausführungszeit für einen Prompt in Sekunden.

run_prompt-Methode

response = chat.run_prompt(
    user_prompt: str,
    conversation_history: list[dict] | None = None,
    disable_tools: list[str] | None = None,
    max_runtime: int | None = None
) -> dict

Parameter:

user_prompt (str): Die Nachricht oder Frage des Benutzers.
conversation_history (list[dict] | None): Optionaler Gesprächsverlauf als Liste von Rollen-/Inhalts-Paaren.
disable_tools (list[str] | None): Liste von Tool-Namen, die für diesen Aufruf deaktiviert werden sollen.
max_runtime (int | None): Überschreibt die standardmäßige maximale Laufzeit für diesen spezifischen Aufruf.

Rückgabewert:

{
    "content": str,           # LLM-Antworttext
    "tool_calls": list,       # Liste der ausgeführten Tool-Aufrufe (falls vorhanden)
    "usage": dict | None,     # Token-Nutzung, sofern vom LLM verfügbar
    "error": str | None       # Fehlermeldung, falls ein Fehler aufgetreten ist
}

Tool-Registry

Die ToolRegistry verwaltet alle Tools, die der Chat-Sitzung zur Verfügung stehen:

Integrierte Tools: Dateioperationen (lesen/schreiben/auflisten)
MCP-Tools: Von MCP-Servern abgerufene Tools
Benutzerdefinierte Tools: Über den Parameter tool_list definierte Tools

Beispiele

Um die Standardpfade zu überschreiben, können Sie die folgenden Variablen setzen. Diese werden in ChatSession geprüft.

TS_LLM_MODEL=qwen3-coder-next TS_LLM_ENDPOINT=http://HOSTNAME:1234/v1/chat/completions
# Beispielverwendung
export TS_LLM_MODEL=qwen3-coder-next
export TS_LLM_ENDPOINT=http://HOSTNAME:1234/v1/chat/completions
ts_llmlib-redclippy
# ODER
TS_LLM_MODEL=qwen3-coder-next TS_LLM_ENDPOINT=http://HOSTNAME:1234/v1/chat/completions ts_llmlib-redclippy

C/C++-Quellcode-Analyse

Analysiert C/C++-Quelldateien auf Sicherheitslücken:

ts_llmlib-cpp-analyze <source_folder> <output_folder>

Ghidra-Binäranalyse

Reverse-Engineering-Binäranalyse mit Ghidra-Integration:

# Grundlegende Analyse
ts_llmlib-ghidra-analyze <output_folder>

# Nur-Umbenennen-Modus (erster Durchlauf)
ts_llmlib-ghidra-analyze --rename_only <output_folder>

# Nur zuvor unbenannte Funktionen verarbeiten
ts_llmlib-ghidra-analyze --process_unnamed_only <output_folder>

# Gruppierte Analyse zur Gruppierung von Aufrufbeziehungen
ts_llmlib-ghidra-analyze --grouped <output_folder>

Wenn der Lauf abgeschlossen ist und Sie nicht --rename_only verwendet haben, können Sie die Struktur bereinigen, indem Sie Folgendes ausführen:

ts_llmlib-ghidra-cleanup <input_folder> <output_folder>

Generierung von Schwachstellenberichten

Erzeugt formatierte Schwachstellenberichte aus JSON-Review-Dateien:

ts_llmlib-ghidra-report <review_folder>

GUI-Chat-Anwendung

Starten Sie die auf Qt basierende Chat-Oberfläche RedClippy (Hinweis: Dieses Beispiel erfordert pyside6):

ts_llmlib-redclippy

Konfigurationsoptionen

LLM-Endpunkt-Konfiguration

ts_llmlib verbindet sich mit jedem OpenAI-kompatiblen API-Endpunkt. Häufige lokale LLM-Server:

Server	Standard-URL
Ollama	`http://localhost:11434/v1/chat/completions`
LM Studio	`http://localhost:1234/v1/chat/completions`
vLLM	`http://localhost:8000/v1/chat/completions`

Zeitlimits

Zwei Timeout-Einstellungen steuern die Ausführung:

HTTP-Timeout (timeout): Maximale Zeit für eine einzelne API-Anfrage
Maximale Laufzeit (max_runtime): Gesamte real verstrichene Zeit, die für die Prompt-Verarbeitung erlaubt ist (einschließlich Tool-Aufrufen)

Wenn eines der Limits überschritten wird, enthält die Antwort eine Fehlermeldung.

Fehlerbehandlung

Alle Fehler werden im Antwort-Dictionary zurückgegeben:

response = chat.run_prompt("Some prompt")

if response.get('error'):
    print(f"Error: {response['error']}")
else:
    print(response['content'])

Häufige Fehler

HTTP-Fehler: Verbindung abgelehnt, Timeout, ungültiger API-Schlüssel
JSON-Parse-Fehler: Ungültige Tool-Argumente oder fehlerhaft formatierte Antworten
Tool-Ausführungsfehler: Fehlende Dateien, Berechtigungsprobleme, ungültige Parameter
Timeout-Fehler: Operation hat das Limit max_runtime überschritten

Projektstruktur

ts_llmlib/
├── __init__.py          # Paketinitialisierung, exportiert ChatSession
├── client.py            # LLMClient für HTTP-Anfragen an LLM-Endpunkte
├── chat.py              # ChatSession-Klasse (Haupt-API)
├── mcp.py               # MCPClient für die Model-Context-Protocol-Integration
├── tools.py             # ToolRegistry für die Tool-Verwaltung
├── HOW_TO_TS_LLMLIB.md  # Originaldokumentation
└── examples/            # Beispielskripte
    ├── c_cpp_analyze.py     # C/C++-Schwachstellenanalyse-Skript
    ├── redclippy.py         # Auf Qt basierende GUI-Chat-Anwendung
    ├── ghidra_analyze.py    # Ghidra-Binäranalyse mit MCP-Integration
    ├── ghidra_vuln_report.py  # Generator für Schwachstellenberichte
    ├── ghidra_cleanup.py    # Dienstprogramm zur Neuorganisation von Ausgabedateien
    └── example_ts_llmlib.py # Beispielskript zur Demonstration der Bibliotheksnutzung

pyproject.toml         # Moderne Python-Paketkonfiguration (Skripte hier definiert)
LICENSE.txt            # BSD-3-Clause-Lizenz
README.md              # Diese Datei

Lizenz

BSD-3-Clause-Lizenz – Weitere Informationen finden Sie in der Datei LICENSE.txt.

Mitwirken

Beiträge sind willkommen! Sie können gerne einen Pull-Request einreichen.

Forken Sie das Repository
Erstellen Sie Ihren Feature-Branch (git checkout -b feature/AmazingFeature)
Committen Sie Ihre Änderungen (git commit -m 'Add some AmazingFeature')
Pushen Sie den Branch (git push origin feature/AmazingFeature)
Öffnen Sie einen Pull-Request

`read_local_file`	`path: str`	Inhalte aus einer lokalen Datei lesen
`write_local_file`	`path: str, content: str`	Inhalte in eine lokale Datei schreiben
`list_directory`	`path: str`	Dateien und Verzeichnisse in einem Pfad auflisten

TS_LLMLib

Beliebteste