Intelligent DMS Blueprint

// In DocumentController.php
public function uploadReceipt(Request $request)
{
    $request->validate(['receipt' => 'required|image|max:10240']);
    $path = $request->file('receipt')->store('temp-receipts');

    ProcessReceiptJob::dispatch(storage_path('app/' . $path), auth()->user());

    return response()->json(['message' => 'Receipt is being processed.'], 202);
}

Given the following text from a receipt, extract the information into a valid JSON object. The JSON must have the following keys: "vendor_name", "transaction_date" (in YYYY-MM-DD format), "total_amount" (as a float), "currency", "invoice_number" (if present), and "line_items" (an array of objects with "description" and "price").

Text:
"""
{{receipt_text}}
"""

// Example Cypher Query
MERGE (d:Document {mongo_id: $mongoId, type: 'Receipt'})
MERGE (u:User {id: $userId})
MERGE (v:Vendor {name: $vendorName})
MERGE (dep:Department {name: $userDepartment})

MERGE (u)-[:UPLOADED]->(d)
MERGE (d)-[:INVOICED_BY]->(v)
MERGE (d)-[:FILED_BY_DEPARTMENT]->(dep)

Analyze the following text from a user and extract the financial transaction details into a JSON object. The keys should be "payee", "amount", "currency", "transaction_date", and "category". Infer today's date if not specified.

Text:
"""
{{chat_message}}
"""

Analyze the user's search query and extract the following parameters as a JSON object: "document_type", "vendor_name", "start_date", "end_date", "topic".

Query: "show me all invoices from ACME Corp in Q4 2023"

// Expected Gemini Response:
{
  "document_type": "Invoice",
  "vendor_name": "ACME Corp",
  "start_date": "2023-10-01",
  "end_date": "2023-12-31"
}

// In your service
$cypher = "MATCH (d:Document)-[:INVOICED_BY]->(v:Vendor) WHERE v.name = \$vendorName AND d.date >= date(\$startDate) AND d.date <= date(\$endDate) RETURN d";
$params = [...];
$results = $neo4jService->query($cypher, $params);

Based on the document content below, classify it into one of the following predefined topics. Respond with ONLY the corresponding topic_code.

Available Topics:
- [FIN-01] Vendor Invoice
- [FIN-02] Expense Report
- [HR-01] Employment Contract
- [LEG-01] Non-Disclosure Agreement

Document Content:
"""
{{document_text}}
"""

// Query to get the max sequence number
MATCH (d:Document)
WHERE d.ownership = $ownership AND d.department = $department AND d.topic = $topic
RETURN max(d.sequence) as maxSequence

// app/Services/GeminiService.php

use Google\Cloud\AIPlatform\V1\GenerateContentRequest;
use Google\Cloud\AIPlatform\V1\VertexAI\GeminiClient;

class GeminiService
{
    // ... other methods

    /**
     * Generates a response from Gemini and streams the result.
     *
     * @param string $prompt
     * @return \Generator
     */
    public function generateStreamedResponse(string $prompt): \Generator
    {
        // Assuming you're using the official Google Cloud PHP library
        // or a similar SDK that supports streaming.

        $client = new GeminiClient(/* ... your config ... */);

        $request = new GenerateContentRequest();
        // Setup your request with the prompt...

        // This is the key part: call the streaming method
        $stream = $client->streamGenerateContent($request);

        foreach ($stream->iterateAllElements() as $response) {
            // Check for errors
            if ($response->getCandidates()->get(0)->getFinishReason()) {
                // You might get stop reasons etc. here
                continue;
            }

            // Yield the actual text chunk
            $textChunk = $response->getCandidates()->get(0)->getContent()->getParts()->get(0)->getText();
            yield $textChunk;
        }
    }
}

// app/Http/Controllers/DocumentController.php

use App\Services\GeminiService;
use Symfony\Component\HttpFoundation\StreamedResponse;

class DocumentController extends Controller
{
    // ... other methods

    public function streamSearch(Request $request, GeminiService $geminiService)
    {
        $query = $request->input('q', 'list all documents');

        // Create the prompt for Gemini to generate the Cypher query or a summary
        $prompt = "Based on the user query, provide a natural language summary and then the structured data. Query: '{$query}'";

        $response = new StreamedResponse(function () use ($geminiService, $prompt) {
            // Set headers for SSE
            header('Content-Type', 'text/event-stream');
            header('Cache-Control', 'no-cache');
            header('X-Accel-Buffering', 'no'); // Important for Nginx

            $stream = $geminiService->generateStreamedResponse($prompt);

            foreach ($stream as $chunk) {
                // Format the chunk for SSE: "data: {content}\n\n"
                echo "data: " . json_encode(['text' => $chunk]) . "\n\n";

                // Flush the output buffer to send the data immediately
                ob_flush();
                flush();
            }

            // After the text stream, you can send the final structured data
            // For example, run the actual Neo4j query and send the results
            // $structuredResults = $this->runNeo4jSearch($query);
            // echo "event: final_data\n";
            // echo "data: " . json_encode($structuredResults) . "\n\n";
            // ob_flush();
            // flush();

        });

        return $response;
    }
}

// In your Vue/React component or plain JS file

const chatOutput = document.getElementById('chat-output');
const resultsTable = document.getElementById('results-table');

const query = "show me all invoices from ACME Corp in Q4 2023";

// 1. Initialize the EventSource
// Use a POST request if you need to send a larger body, which requires a polyfill
// or a different approach. For GET, this is straightforward.
const eventSource = new EventSource(`/api/documents/stream-search?q=${encodeURIComponent(query)}`);

// 2. Listen for incoming messages
eventSource.onmessage = function(event) {
    const data = JSON.parse(event.data);

    // Append the text chunk to the display
    // Note: Gemini might send whitespace chunks, you might want to filter them
    if (data.text) {
        chatOutput.innerHTML += data.text.replace(/\n/g, '<br>');
    }
};

// Optional: Listen for a custom event for your final structured data
eventSource.addEventListener('final_data', function(event) {
    const structuredResults = JSON.parse(event.data);

    // Render the table with the structured results
    renderTable(structuredResults);

    // 4. Close the connection once you have the final data
    eventSource.close();
});


// 3. Handle errors and stream closing
eventSource.onerror = function(err) {
    console.error("EventSource failed:", err);
    eventSource.close();
};

function renderTable(data) {
    // Your logic to build the expandable table from the JSON data
    console.log("Rendering final table:", data);
}

// app/Data/ReceiptData.php
namespace App\Data;

use Prism\Attributes\Description;

class ReceiptData
{
    #[Description('The name of the vendor or store.')]
    public string $vendor_name;

    #[Description('The full transaction date in YYYY-MM-DD format.')]
    public string $transaction_date;

    #[Description('The total amount of the transaction as a float.')]
    public float $total_amount;

    #[Description('The ISO 4217 currency code, e.g., USD, IDR.')]
    public ?string $currency;

    #[Description('The unique invoice or receipt number, if present.')]
    public ?string $invoice_number;

    #[Description("Classify this document based on its content. Available options are: FIN-01, FIN-02, HR-01, LEG-01")]
    public string $topic_code;
}

// app/Jobs/ProcessReceiptJob.php
use App\Data\ReceiptData;
use Prism\Prism;

public function handle()
{
    // $this->imagePath is the path to the uploaded image

    // Prism handles the multi-modal request and structured data extraction!
    /** @var ReceiptData $extractedData */
    $extractedData = Prism::model('gemini-1.5-pro') // Or your preferred Gemini vision model
        ->prompt([
            'Analyze the attached receipt image and extract the key information.',
            'The current date is ' . now()->toDateString() . ' for reference.',
            \Prism\File::fromPath($this->imagePath), // This is the magic for multi-modal
        ])
        ->structured(ReceiptData::class); // Ask Prism to populate your DTO

    // $extractedData is now a fully typed PHP object!
    // $extractedData->vendor_name;
    // $extractedData->topic_code;

    // Now, continue with your logic...
    // 1. Generate Call Code using the $extractedData->topic_code and invoice_number
    // $callCode = $this->callCodeGenerator->generate(...);

    // 2. Store in MongoDB
    // ReceiptModel::create([...$extractedData, 'call_code' => $callCode]);

    // 3. Create Graph in Neo4j
    // ...
}

// app/Http/Controllers/DocumentController.php

use Illuminate\Http\Request;
use Prism\Prism;
use Symfony\Component\HttpFoundation\StreamedResponse;

class DocumentController extends Controller
{
    public function streamSearch(Request $request)
    {
        $query = $request->input('q', 'list all documents');

        // This could be a simple prompt or a more complex one
        // that includes your Neo4j schema for better Cypher generation.
        $prompt = "You are a helpful assistant for a Document Management System.
                   Answer the user's question. The question is: '{$query}'";

        $response = new StreamedResponse(function () use ($prompt) {
            // Set SSE headers
            header('Content-Type', 'text/event-stream');
            header('Cache-Control', 'no-cache');
            header('X-Accel-Buffering', 'no');

            // Get the stream directly from Prism
            $stream = Prism::model('gemini-1.5-pro')->prompt($prompt)->stream();

            // Loop and send
            foreach ($stream as $chunk) {
                echo "data: " . json_encode(['text' => $chunk->content]) . "\n\n";
                ob_flush();
                flush();
            }
        });

        return $response;
    }
}

// In your ProcessReceiptJob after extracting text
use Prism\Prism;
use App\Services\Neo4jService;

// ... after getting structured data ...

$documentText = "Vendor: {$data->vendor_name}, Total: {$data->total_amount}, Date: {$data->transaction_date}..."; // Or full text

// 1. Generate embedding with Prism
$embedding = Prism::embedding('text-embedding-004') // Use Google's embedding model
    ->embed($documentText);

// 2. Store the document and its embedding in Neo4j
$neo4jService->query(
    "MERGE (d:Document {mongo_id: \$mongoId})
     SET d.text = \$text, d.embedding = \$embedding, d.vendor = \$vendorName
     // ... other properties",
    [
        'mongo_id' => $mongoId,
        'text' => $documentText,
        'embedding' => $embedding, // Pass the vector array
        'vendorName' => $data->vendor_name,
    ]
);

// IMPORTANT: You must have a vector index in Neo4j for this to be fast!
// CREATE VECTOR INDEX document_embeddings IF NOT EXISTS
// FOR (d:Document) ON (d.embedding)
// OPTIONS { indexConfig: { `vector.dimensions`: 768, `vector.similarity_function`: 'cosine' }}

// app/Data/SearchParameters.php
namespace App\Data;

class SearchParameters
{
    public ?string $document_type = null;
    public ?string $vendor_name = null;
    public ?string $topic_code = null;
    public ?string $start_date = null;
    public ?string $end_date = null;
    public ?string $searchTerm = null; // For general semantic search
}

// app/Services/GraphRagService.php
namespace App\Services;

use App\Data\SearchParameters;
use Prism\Prism;

class GraphRagService
{
    public function __construct(protected Neo4jService $neo4j) {}

    public function retrieveContext(string $userQuery): string
    {
        // Step 2a: Use Prism to extract entities from the query
        /** @var SearchParameters $params */
        $params = Prism::model('gemini-1.5-pro')
            ->prompt("Extract search parameters from the user's query: '{$userQuery}'")
            ->structured(SearchParameters::class);

        // Step 2b: Build a dynamic Cypher query from the extracted parameters
        $cypher = "MATCH (d:Document) ";
        $queryParams = [];
        $whereClauses = [];

        if ($params->vendor_name) {
            $cypher .= "MATCH (d)-[:INVOICED_BY]->(v:Vendor) ";
            $whereClauses[] = "v.name CONTAINS \$vendor";
            $queryParams['vendor'] = $params->vendor_name;
        }

        // ... add more conditions for date, topic_code etc.

        if (!empty($whereClauses)) {
            $cypher .= "WHERE " . implode(' AND ', $whereClauses) . " ";
        }

        $cypher .= "RETURN d.text, d.call_code, d.vendor LIMIT 5";

        // Step 2c: Execute the query
        $results = $this->neo4j->query($cypher, $queryParams);

        // Step 2d: Format the results into a string context
        if (empty($results)) {
            return "No relevant documents found in the knowledge graph.";
        }

        $context = "Here is some context found in the Document Management System:\n";
        foreach ($results as $record) {
            $context .= "- Call Code: " . $record['d.call_code'] . "\n  Content: " . $record['d.text'] . "\n\n";
        }

        return $context;
    }
}

// Add this method to GraphRagService.php

public function retrieveVectorContext(string $userQuery): string
{
    // 1. Get embedding for the user's query
    $queryEmbedding = Prism::embedding('text-embedding-004')->embed($userQuery);

    // 2. Perform a vector similarity search in Neo4j
    $cypher = "
      CALL db.index.vector.queryNodes('document_embeddings', 5, \$embedding) YIELD node, score
      RETURN node.text, node.call_code, score
    ";

    $results = $this->neo4j->query($cypher, ['embedding' => $queryEmbedding]);

    // 3. Format the results into a context string (same as above)
    // ...
    return $context;
}

// app/Http/Controllers/DocumentController.php

use App\Services\GraphRagService;
use Illuminate\Http\Request;
use Prism\Prism;
use Symfony\Component\HttpFoundation\StreamedResponse;

class DocumentController extends Controller
{
    public function streamSearch(Request $request, GraphRagService $ragService)
    {
        $query = $request->input('q');

        // 1. RETRIEVE: Get context from your knowledge graph
        $context = $ragService->retrieveContext($query);
        // You could also call retrieveVectorContext() and merge the strings

        // 2. AUGMENT: Create the final, augmented prompt
        $augmentedPrompt = <<<PROMPT
        You are a helpful assistant for a Document Management System.
        Use the following context to answer the user's question.
        If the context doesn't contain the answer, say you couldn't find the information.

        --- CONTEXT ---
        {$context}
        --- END CONTEXT ---

        User Question: {$query}
        Answer:
        PROMPT;

        // 3. GENERATE: Use Prism to stream the final answer
        $response = new StreamedResponse(function () use ($augmentedPrompt) {
            // ... (SSE headers as before) ...

            $stream = Prism::model('gemini-1.5-pro')
                ->prompt($augmentedPrompt)
                ->stream();

            foreach ($stream as $chunk) {
                echo "data: " . json_encode(['text' => $chunk->content]) . "\n\n";
                ob_flush();
                flush();
            }
        });

        return $response;
    }
}