How AI Is Transforming Legal Practice Management: Contract Analysis, Call Summaries, and Intelligent Matter Insights with .NET

// ContractAnalysisService.cs
public class ContractAnalysisService
{
    private readonly Kernel _kernel;

    public async Task<ContractAnalysis> AnalyseAsync(
        string contractText,
        string[] clausesToExtract)
    {
        // Build a structured prompt that tells the AI exactly
        // what to look for and how to format the response
        var clauseList = string.Join("\n",
            clausesToExtract.Select((c, i) => $"{i + 1}. {c}"));

        var prompt = $"""
            You are a precise legal document analyst.
            Analyse this contract and extract the following clauses.
            For each clause:
            - Quote the exact relevant text from the contract
            - State the page/section reference if visible
            - Provide a plain-English summary in 1-2 sentences
            - Flag any unusual or potentially risky terms

            Clauses to extract:
            {clauseList}

            Return ONLY valid JSON:
            {{
              "clauses": [
                {{
                  "clauseName":    "string",
                  "exactQuote":    "string or null if not found",
                  "sectionRef":    "string or null",
                  "summary":       "string",
                  "riskFlag":      "None | Low | Medium | High",
                  "riskNote":      "string or null"
                }}
              ],
              "overallRisk":      "None | Low | Medium | High",
              "recommendReview":  true/false,
              "analysisNotes":    "string"
            }}

            CONTRACT TEXT:
            {contractText}
            """;

        var result = await _kernel
            .InvokePromptAsync<string>(prompt,
                new KernelArguments(
                    new PromptExecutionSettings
                    {
                        // Low temperature = deterministic extraction
                        ExtensionData = new() {{ "temperature", 0.1 }}
                    }));

        return JsonSerializer.Deserialize<ContractAnalysis>(result!)!;
    }
}

// Usage in a Blazor component
@inject ContractAnalysisService ContractAI

@code {
    private ContractAnalysis? _analysis;
    private bool _loading;

    private async Task AnalyseContract()
    {
        _loading  = true;
        _analysis = await ContractAI.AnalyseAsync(
            contractText: _uploadedText,
            clausesToExtract: new[]
            {
                "Termination clause",
                "Limitation of liability",
                "Payment terms and late fees",
                "Confidentiality obligations",
                "Governing law and jurisdiction"
            });
        _loading = false;
    }
}

public class CallSummaryService
{
    private readonly Kernel _kernel;

    public async Task<CallSummary> SummariseTranscriptAsync(
        string transcript,
        string matterTitle,
        string clientName)
    {
        var prompt = $"""
            You are a legal practice assistant.
            Summarise this client call transcript for a law firm matter file.

            Matter: {matterTitle}
            Client: {clientName}

            Create a professional matter note with:
            1. A 3-5 sentence summary of what was discussed
            2. Key decisions made during the call
            3. Action items (who is responsible, what they need to do)
            4. Any deadlines or dates mentioned
            5. Follow-up questions the attorney should address

            Return ONLY valid JSON:
            {{
              "summary":         "string",
              "keyDecisions":    ["string"],
              "actionItems": [
                {{
                  "assignedTo":  "Attorney | Client | Both",
                  "action":      "string",
                  "deadline":    "string or null"
                }}
              ],
              "importantDates":  [{{ "description": "string", "date": "string" }}],
              "followUpItems":   ["string"],
              "callDurationMins": number or null,
              "sentimentScore":  "Positive | Neutral | Concerned | Urgent"
            }}

            TRANSCRIPT:
            {transcript}
            """;

        var result = await _kernel.InvokePromptAsync<string>(prompt,
            new KernelArguments(
                new PromptExecutionSettings
                {
                    ExtensionData = new() {{ "temperature", 0.2 }}
                }));

        var summary = JsonSerializer.Deserialize<CallSummary>(result!)!;

        // Auto-format as a Clio-ready note
        summary.FormattedNote = FormatAsClioNote(summary, matterTitle);
        return summary;
    }

    private static string FormatAsClioNote(
        CallSummary s, string matterTitle)
    {
        var sb = new StringBuilder();
        sb.AppendLine($"## Call Summary — {DateTime.Today:dd MMM yyyy}");
        sb.AppendLine($"**Matter:** {matterTitle}");
        sb.AppendLine($"**Sentiment:** {s.SentimentScore}\n");
        sb.AppendLine("### Summary");
        sb.AppendLine(s.Summary + "\n");

        if (s.KeyDecisions.Any())
        {
            sb.AppendLine("### Decisions Made");
            foreach (var d in s.KeyDecisions)
                sb.AppendLine($"- {d}");
            sb.AppendLine();
        }

        if (s.ActionItems.Any())
        {
            sb.AppendLine("### Action Items");
            foreach (var a in s.ActionItems)
            {
                var deadline = a.Deadline != null
                    ? $" (by {a.Deadline})" : "";
                sb.AppendLine(
                    $"- [{a.AssignedTo}] {a.Action}{deadline}");
            }
        }

        return sb.ToString();
    }
}

// Semantic search using Azure OpenAI embeddings + pgvector / MS-SQL
public class MatterSearchService
{
    private readonly Kernel          _kernel;
    private readonly MatterDbContext _db;

    // Called when a new matter is created — store its embedding
    public async Task IndexMatterAsync(Matter matter)
    {
        // Create a rich text representation of the matter
        var text = $"""
            Matter: {matter.DisplayNumber}
            Description: {matter.Description}
            Practice Area: {matter.PracticeArea}
            Client: {matter.ClientName}
            Notes: {string.Join(" ", matter.RecentNotes.Take(3))}
            """;

        // Generate embedding vector
        var embeddingService = _kernel
            .GetRequiredService<ITextEmbeddingGenerationService>();

        var embedding = await embeddingService
            .GenerateEmbeddingAsync(text);

        // Store embedding alongside the matter
        matter.SearchEmbedding = embedding.ToArray();
        await _db.SaveChangesAsync();
    }

    // Semantic search — understands meaning, not just keywords
    public async Task<List<MatterSearchResult>> SearchAsync(
        string          query,
        int             topK     = 10,
        string?         practiceArea = null)
    {
        var embeddingService = _kernel
            .GetRequiredService<ITextEmbeddingGenerationService>();

        // Embed the search query with the same model
        var queryEmbedding = await embeddingService
            .GenerateEmbeddingAsync(query);

        // Vector similarity search — finds semantically similar matters
        // Using cosine similarity (works with both pgvector and custom SQL)
        var results = await _db.Matters
            .Where(m => practiceArea == null ||
                        m.PracticeArea == practiceArea)
            .Select(m => new
            {
                Matter = m,
                // Cosine similarity between query and stored embedding
                Score = CosineSimilarity(
                    m.SearchEmbedding, queryEmbedding.ToArray())
            })
            .OrderByDescending(x => x.Score)
            .Take(topK)
            .ToListAsync();

        return results
            .Where(r => r.Score > 0.75) // threshold — ignore weak matches
            .Select(r => new MatterSearchResult
            {
                Matter         = r.Matter,
                SimilarityScore = r.Score,
                MatchReason    = r.Score > 0.92
                    ? "Very strong match"
                    : r.Score > 0.85
                    ? "Strong match"
                    : "Possible match"
            })
            .ToList();
    }
}